// $ANTLR 3.2 Sep 23, 2009 12:02:23 E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g 2011-12-12 16:51:51

	package it.uniroma2.art.coda.projectionrule.antlr;
	import it.uniroma2.art.coda.projectionrule.antlr.AntlrParserRuntimeException;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;


import org.antlr.runtime.tree.*;

public class AntlrParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE", "ID", "Conf", "DependsOn", "Imports", "DependType1", "DependType2", "DependType3", "DependTypeMult", "ALIAS", "NODES", "LITERALTYPE", "IF", "CONDOP", "GRAPH", "OPTIONAL", "ABBR", "WHERE", "PARAMETERS", "SmallWord", "CapitalWord", "Number", "ROOT", "PREFIXPART", "PREFIX", "NAMESPACE", "PRRules", "PRRule", "UIMATYPE", "CONF", "NOALIAS", "SINGLEALIAS", "NONODE", "NODE", "TYPE", "COND", "ELSEIF", "ELSE", "CONDBOOL", "UIMATYPEANDFEATS", "UIMAFEAT", "ONTORES", "NOGRAPH", "TRIPLE", "OPTIONALTRIPLE", "SUBJ", "PRED", "OBJ", "DATATYPEVALUE", "PLACEHOLDER", "VAR", "NOWHERE", "PARAMETERSLIST", "PARAMETER", "PARAMETERNAME", "PARAMETERVALUE", "WS", "NEWLINE", "COMMENT", "MULTILINE_COMMENT", "'='", "';'", "':'", "'{'", "'}'", "','", "'('", "')'", "'uri'", "'plainLiteral'", "'literal'", "'$'", "'.'", "'?'", "'http'", "'ftp'", "'://'", "'/'", "'#'", "'['", "']'", "'_'", "'<'", "'>'", "'\\\"'", "'-'"
    };
    public static final int T__68=68;
    public static final int PREFIX=28;
    public static final int T__69=69;
    public static final int WHERE=21;
    public static final int T__66=66;
    public static final int T__67=67;
    public static final int T__64=64;
    public static final int T__65=65;
    public static final int PARAMETERS=22;
    public static final int GRAPH=18;
    public static final int Conf=6;
    public static final int NOALIAS=34;
    public static final int PARAMETERNAME=58;
    public static final int ID=5;
    public static final int EOF=-1;
    public static final int TYPE=38;
    public static final int ABBR=20;
    public static final int IF=16;
    public static final int PARAMETERVALUE=59;
    public static final int MULTILINE_COMMENT=63;
    public static final int NONODE=36;
    public static final int Number=25;
    public static final int OBJ=51;
    public static final int DATATYPEVALUE=52;
    public static final int PRRules=30;
    public static final int PARAMETER=57;
    public static final int NODES=14;
    public static final int DependType1=9;
    public static final int VAR=54;
    public static final int DependType3=11;
    public static final int DependTypeMult=12;
    public static final int DependType2=10;
    public static final int TRIPLE=47;
    public static final int COMMENT=62;
    public static final int SINGLEALIAS=35;
    public static final int PARAMETERSLIST=56;
    public static final int PLACEHOLDER=53;
    public static final int NOWHERE=55;
    public static final int T__80=80;
    public static final int T__81=81;
    public static final int NODE=37;
    public static final int T__82=82;
    public static final int RULE=4;
    public static final int T__83=83;
    public static final int PREFIXPART=27;
    public static final int PRED=50;
    public static final int ELSE=41;
    public static final int CONDOP=17;
    public static final int T__85=85;
    public static final int Imports=8;
    public static final int NOGRAPH=46;
    public static final int T__84=84;
    public static final int ROOT=26;
    public static final int SmallWord=23;
    public static final int T__87=87;
    public static final int OPTIONALTRIPLE=48;
    public static final int T__86=86;
    public static final int T__89=89;
    public static final int SUBJ=49;
    public static final int NAMESPACE=29;
    public static final int T__88=88;
    public static final int OPTIONAL=19;
    public static final int ELSEIF=40;
    public static final int WS=60;
    public static final int UIMATYPEANDFEATS=43;
    public static final int T__71=71;
    public static final int T__72=72;
    public static final int NEWLINE=61;
    public static final int UIMAFEAT=44;
    public static final int T__70=70;
    public static final int LITERALTYPE=15;
    public static final int ALIAS=13;
    public static final int CONDBOOL=42;
    public static final int CapitalWord=24;
    public static final int PRRule=31;
    public static final int T__76=76;
    public static final int COND=39;
    public static final int T__75=75;
    public static final int ONTORES=45;
    public static final int T__74=74;
    public static final int T__73=73;
    public static final int UIMATYPE=32;
    public static final int T__79=79;
    public static final int T__78=78;
    public static final int DependsOn=7;
    public static final int CONF=33;
    public static final int T__77=77;

    // delegates
    // delegators


        public AntlrParser(TokenStream input) {
            this(input, new RecognizerSharedState());
        }
        public AntlrParser(TokenStream input, RecognizerSharedState state) {
            super(input, state);
             
        }
        
    protected TreeAdaptor adaptor = new CommonTreeAdaptor();

    public void setTreeAdaptor(TreeAdaptor adaptor) {
        this.adaptor = adaptor;
    }
    public TreeAdaptor getTreeAdaptor() {
        return adaptor;
    }

    public String[] getTokenNames() { return AntlrParser.tokenNames; }
    public String getGrammarFileName() { return "E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g"; }


    @Override
      public void reportError(RecognitionException e) {
      	String msg = "Parser error";
    	 	if(e instanceof UnwantedTokenException){
    		 	String text = ((UnwantedTokenException)e).getUnexpectedToken().getText();
    		 	int line = ((UnwantedTokenException)e).getUnexpectedToken().getLine();
    		 	int pos = ((UnwantedTokenException)e).getUnexpectedToken().getCharPositionInLine();
    		 	msg += " with text = "+text+" at line "+line+" and char "+pos;
    	 	}
    	 	else if(e instanceof MismatchedTokenException){
    	 		System.out.println(((MismatchedTokenException)e).getLocalizedMessage()); // da cancellare
    	 	}
    	 	else{
    	 		System.out.println("&&& e.getClass() = "+e.getClass()); // da cancellare
    	 	}
    	 	//System.out.println("&&& Problem with text = "+text+" at line "+line+" and char "+pos); // da cancellare
    	 	
    	 	throw new AntlrParserRuntimeException(msg);
    	  //throw new IllegalArgumentException(e);
      }



    public static class prRules_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "prRules"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:69:1: prRules : ( prefixRule )* ( prRule )+ -> ^( ROOT ^( PREFIXPART ( prefixRule )* ) ^( PRRules ( prRule )+ ) ) ;
    public final AntlrParser.prRules_return prRules() throws RecognitionException {
        AntlrParser.prRules_return retval = new AntlrParser.prRules_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AntlrParser.prefixRule_return prefixRule1 = null;

        AntlrParser.prRule_return prRule2 = null;


        RewriteRuleSubtreeStream stream_prRule=new RewriteRuleSubtreeStream(adaptor,"rule prRule");
        RewriteRuleSubtreeStream stream_prefixRule=new RewriteRuleSubtreeStream(adaptor,"rule prefixRule");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:70:2: ( ( prefixRule )* ( prRule )+ -> ^( ROOT ^( PREFIXPART ( prefixRule )* ) ^( PRRules ( prRule )+ ) ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:70:5: ( prefixRule )* ( prRule )+
            {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:70:5: ( prefixRule )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==SmallWord) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:70:5: prefixRule
            	    {
            	    pushFollow(FOLLOW_prefixRule_in_prRules72);
            	    prefixRule1=prefixRule();

            	    state._fsp--;

            	    stream_prefixRule.add(prefixRule1.getTree());

            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:70:17: ( prRule )+
            int cnt2=0;
            loop2:
            do {
                int alt2=2;
                int LA2_0 = input.LA(1);

                if ( (LA2_0==RULE) ) {
                    alt2=1;
                }


                switch (alt2) {
            	case 1 :
            	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:70:17: prRule
            	    {
            	    pushFollow(FOLLOW_prRule_in_prRules75);
            	    prRule2=prRule();

            	    state._fsp--;

            	    stream_prRule.add(prRule2.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt2 >= 1 ) break loop2;
                        EarlyExitException eee =
                            new EarlyExitException(2, input);
                        throw eee;
                }
                cnt2++;
            } while (true);



            // AST REWRITE
            // elements: prefixRule, prRule
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 70:25: -> ^( ROOT ^( PREFIXPART ( prefixRule )* ) ^( PRRules ( prRule )+ ) )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:70:28: ^( ROOT ^( PREFIXPART ( prefixRule )* ) ^( PRRules ( prRule )+ ) )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ROOT, "ROOT"), root_1);

                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:70:35: ^( PREFIXPART ( prefixRule )* )
                {
                Object root_2 = (Object)adaptor.nil();
                root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(PREFIXPART, "PREFIXPART"), root_2);

                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:70:49: ( prefixRule )*
                while ( stream_prefixRule.hasNext() ) {
                    adaptor.addChild(root_2, stream_prefixRule.nextTree());

                }
                stream_prefixRule.reset();

                adaptor.addChild(root_1, root_2);
                }
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:70:62: ^( PRRules ( prRule )+ )
                {
                Object root_2 = (Object)adaptor.nil();
                root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(PRRules, "PRRules"), root_2);

                if ( !(stream_prRule.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_prRule.hasNext() ) {
                    adaptor.addChild(root_2, stream_prRule.nextTree());

                }
                stream_prRule.reset();

                adaptor.addChild(root_1, root_2);
                }

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "prRules"

    public static class prefixRule_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "prefixRule"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:75:1: prefixRule : prefix '=' namespace ';' -> ^( PREFIX prefix ^( NAMESPACE namespace ) ) ;
    public final AntlrParser.prefixRule_return prefixRule() throws RecognitionException {
        AntlrParser.prefixRule_return retval = new AntlrParser.prefixRule_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal4=null;
        Token char_literal6=null;
        AntlrParser.prefix_return prefix3 = null;

        AntlrParser.namespace_return namespace5 = null;


        Object char_literal4_tree=null;
        Object char_literal6_tree=null;
        RewriteRuleTokenStream stream_64=new RewriteRuleTokenStream(adaptor,"token 64");
        RewriteRuleTokenStream stream_65=new RewriteRuleTokenStream(adaptor,"token 65");
        RewriteRuleSubtreeStream stream_prefix=new RewriteRuleSubtreeStream(adaptor,"rule prefix");
        RewriteRuleSubtreeStream stream_namespace=new RewriteRuleSubtreeStream(adaptor,"rule namespace");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:76:2: ( prefix '=' namespace ';' -> ^( PREFIX prefix ^( NAMESPACE namespace ) ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:76:4: prefix '=' namespace ';'
            {
            pushFollow(FOLLOW_prefix_in_prefixRule112);
            prefix3=prefix();

            state._fsp--;

            stream_prefix.add(prefix3.getTree());
            char_literal4=(Token)match(input,64,FOLLOW_64_in_prefixRule114);  
            stream_64.add(char_literal4);

            pushFollow(FOLLOW_namespace_in_prefixRule117);
            namespace5=namespace();

            state._fsp--;

            stream_namespace.add(namespace5.getTree());
            char_literal6=(Token)match(input,65,FOLLOW_65_in_prefixRule119);  
            stream_65.add(char_literal6);



            // AST REWRITE
            // elements: prefix, namespace
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 76:30: -> ^( PREFIX prefix ^( NAMESPACE namespace ) )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:76:33: ^( PREFIX prefix ^( NAMESPACE namespace ) )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PREFIX, "PREFIX"), root_1);

                adaptor.addChild(root_1, stream_prefix.nextTree());
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:76:49: ^( NAMESPACE namespace )
                {
                Object root_2 = (Object)adaptor.nil();
                root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(NAMESPACE, "NAMESPACE"), root_2);

                adaptor.addChild(root_2, stream_namespace.nextTree());

                adaptor.addChild(root_1, root_2);
                }

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "prefixRule"

    public static class prRule_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "prRule"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:79:1: prRule : RULE uimaTypePR ( ID ':' idVal= word )? ( Conf )? ( dependsOn )? ( imports )? '{' ( alias )? ( nodes )? ( graph )? ( where )? ( parameters )? ( ';' )? '}' -> ^( PRRule ( ^( CONF Conf ) )? uimaTypePR ( ^( ID $idVal) )? ( dependsOn )? ( imports )? ( alias )? ( nodes )? ( graph )? ( where )? ( parameters )? ) ;
    public final AntlrParser.prRule_return prRule() throws RecognitionException {
        AntlrParser.prRule_return retval = new AntlrParser.prRule_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token RULE7=null;
        Token ID9=null;
        Token char_literal10=null;
        Token Conf11=null;
        Token char_literal14=null;
        Token char_literal20=null;
        Token char_literal21=null;
        AntlrParser.word_return idVal = null;

        AntlrParser.uimaTypePR_return uimaTypePR8 = null;

        AntlrParser.dependsOn_return dependsOn12 = null;

        AntlrParser.imports_return imports13 = null;

        AntlrParser.alias_return alias15 = null;

        AntlrParser.nodes_return nodes16 = null;

        AntlrParser.graph_return graph17 = null;

        AntlrParser.where_return where18 = null;

        AntlrParser.parameters_return parameters19 = null;


        Object RULE7_tree=null;
        Object ID9_tree=null;
        Object char_literal10_tree=null;
        Object Conf11_tree=null;
        Object char_literal14_tree=null;
        Object char_literal20_tree=null;
        Object char_literal21_tree=null;
        RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
        RewriteRuleTokenStream stream_66=new RewriteRuleTokenStream(adaptor,"token 66");
        RewriteRuleTokenStream stream_Conf=new RewriteRuleTokenStream(adaptor,"token Conf");
        RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68");
        RewriteRuleTokenStream stream_RULE=new RewriteRuleTokenStream(adaptor,"token RULE");
        RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
        RewriteRuleTokenStream stream_65=new RewriteRuleTokenStream(adaptor,"token 65");
        RewriteRuleSubtreeStream stream_graph=new RewriteRuleSubtreeStream(adaptor,"rule graph");
        RewriteRuleSubtreeStream stream_alias=new RewriteRuleSubtreeStream(adaptor,"rule alias");
        RewriteRuleSubtreeStream stream_nodes=new RewriteRuleSubtreeStream(adaptor,"rule nodes");
        RewriteRuleSubtreeStream stream_word=new RewriteRuleSubtreeStream(adaptor,"rule word");
        RewriteRuleSubtreeStream stream_uimaTypePR=new RewriteRuleSubtreeStream(adaptor,"rule uimaTypePR");
        RewriteRuleSubtreeStream stream_parameters=new RewriteRuleSubtreeStream(adaptor,"rule parameters");
        RewriteRuleSubtreeStream stream_dependsOn=new RewriteRuleSubtreeStream(adaptor,"rule dependsOn");
        RewriteRuleSubtreeStream stream_where=new RewriteRuleSubtreeStream(adaptor,"rule where");
        RewriteRuleSubtreeStream stream_imports=new RewriteRuleSubtreeStream(adaptor,"rule imports");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:80:2: ( RULE uimaTypePR ( ID ':' idVal= word )? ( Conf )? ( dependsOn )? ( imports )? '{' ( alias )? ( nodes )? ( graph )? ( where )? ( parameters )? ( ';' )? '}' -> ^( PRRule ( ^( CONF Conf ) )? uimaTypePR ( ^( ID $idVal) )? ( dependsOn )? ( imports )? ( alias )? ( nodes )? ( graph )? ( where )? ( parameters )? ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:80:5: RULE uimaTypePR ( ID ':' idVal= word )? ( Conf )? ( dependsOn )? ( imports )? '{' ( alias )? ( nodes )? ( graph )? ( where )? ( parameters )? ( ';' )? '}'
            {
            RULE7=(Token)match(input,RULE,FOLLOW_RULE_in_prRule146);  
            stream_RULE.add(RULE7);

            pushFollow(FOLLOW_uimaTypePR_in_prRule148);
            uimaTypePR8=uimaTypePR();

            state._fsp--;

            stream_uimaTypePR.add(uimaTypePR8.getTree());
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:80:21: ( ID ':' idVal= word )?
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==ID) ) {
                alt3=1;
            }
            switch (alt3) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:80:22: ID ':' idVal= word
                    {
                    ID9=(Token)match(input,ID,FOLLOW_ID_in_prRule151);  
                    stream_ID.add(ID9);

                    char_literal10=(Token)match(input,66,FOLLOW_66_in_prRule153);  
                    stream_66.add(char_literal10);

                    pushFollow(FOLLOW_word_in_prRule157);
                    idVal=word();

                    state._fsp--;

                    stream_word.add(idVal.getTree());

                    }
                    break;

            }

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:80:42: ( Conf )?
            int alt4=2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==Conf) ) {
                alt4=1;
            }
            switch (alt4) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:80:42: Conf
                    {
                    Conf11=(Token)match(input,Conf,FOLLOW_Conf_in_prRule161);  
                    stream_Conf.add(Conf11);


                    }
                    break;

            }

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:80:48: ( dependsOn )?
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0==DependsOn) ) {
                alt5=1;
            }
            switch (alt5) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:80:48: dependsOn
                    {
                    pushFollow(FOLLOW_dependsOn_in_prRule164);
                    dependsOn12=dependsOn();

                    state._fsp--;

                    stream_dependsOn.add(dependsOn12.getTree());

                    }
                    break;

            }

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:80:59: ( imports )?
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0==Imports) ) {
                alt6=1;
            }
            switch (alt6) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:80:59: imports
                    {
                    pushFollow(FOLLOW_imports_in_prRule167);
                    imports13=imports();

                    state._fsp--;

                    stream_imports.add(imports13.getTree());

                    }
                    break;

            }

            char_literal14=(Token)match(input,67,FOLLOW_67_in_prRule170);  
            stream_67.add(char_literal14);

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:81:5: ( alias )?
            int alt7=2;
            int LA7_0 = input.LA(1);

            if ( (LA7_0==ALIAS) ) {
                alt7=1;
            }
            switch (alt7) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:81:5: alias
                    {
                    pushFollow(FOLLOW_alias_in_prRule176);
                    alias15=alias();

                    state._fsp--;

                    stream_alias.add(alias15.getTree());

                    }
                    break;

            }

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:81:12: ( nodes )?
            int alt8=2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0==NODES) ) {
                alt8=1;
            }
            switch (alt8) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:81:12: nodes
                    {
                    pushFollow(FOLLOW_nodes_in_prRule179);
                    nodes16=nodes();

                    state._fsp--;

                    stream_nodes.add(nodes16.getTree());

                    }
                    break;

            }

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:81:19: ( graph )?
            int alt9=2;
            int LA9_0 = input.LA(1);

            if ( (LA9_0==GRAPH) ) {
                alt9=1;
            }
            switch (alt9) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:81:19: graph
                    {
                    pushFollow(FOLLOW_graph_in_prRule182);
                    graph17=graph();

                    state._fsp--;

                    stream_graph.add(graph17.getTree());

                    }
                    break;

            }

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:81:26: ( where )?
            int alt10=2;
            int LA10_0 = input.LA(1);

            if ( (LA10_0==WHERE) ) {
                alt10=1;
            }
            switch (alt10) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:81:26: where
                    {
                    pushFollow(FOLLOW_where_in_prRule185);
                    where18=where();

                    state._fsp--;

                    stream_where.add(where18.getTree());

                    }
                    break;

            }

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:81:33: ( parameters )?
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( (LA11_0==PARAMETERS) ) {
                alt11=1;
            }
            switch (alt11) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:81:33: parameters
                    {
                    pushFollow(FOLLOW_parameters_in_prRule188);
                    parameters19=parameters();

                    state._fsp--;

                    stream_parameters.add(parameters19.getTree());

                    }
                    break;

            }

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:81:45: ( ';' )?
            int alt12=2;
            int LA12_0 = input.LA(1);

            if ( (LA12_0==65) ) {
                alt12=1;
            }
            switch (alt12) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:81:45: ';'
                    {
                    char_literal20=(Token)match(input,65,FOLLOW_65_in_prRule191);  
                    stream_65.add(char_literal20);


                    }
                    break;

            }

            char_literal21=(Token)match(input,68,FOLLOW_68_in_prRule194);  
            stream_68.add(char_literal21);



            // AST REWRITE
            // elements: nodes, graph, where, idVal, alias, ID, parameters, imports, uimaTypePR, dependsOn, Conf
            // token labels: 
            // rule labels: retval, idVal
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
            RewriteRuleSubtreeStream stream_idVal=new RewriteRuleSubtreeStream(adaptor,"rule idVal",idVal!=null?idVal.tree:null);

            root_0 = (Object)adaptor.nil();
            // 82:4: -> ^( PRRule ( ^( CONF Conf ) )? uimaTypePR ( ^( ID $idVal) )? ( dependsOn )? ( imports )? ( alias )? ( nodes )? ( graph )? ( where )? ( parameters )? )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:82:7: ^( PRRule ( ^( CONF Conf ) )? uimaTypePR ( ^( ID $idVal) )? ( dependsOn )? ( imports )? ( alias )? ( nodes )? ( graph )? ( where )? ( parameters )? )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PRRule, "PRRule"), root_1);

                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:82:16: ( ^( CONF Conf ) )?
                if ( stream_Conf.hasNext() ) {
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:82:17: ^( CONF Conf )
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(CONF, "CONF"), root_2);

                    adaptor.addChild(root_2, stream_Conf.nextNode());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_Conf.reset();
                adaptor.addChild(root_1, stream_uimaTypePR.nextTree());
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:82:43: ( ^( ID $idVal) )?
                if ( stream_idVal.hasNext()||stream_ID.hasNext() ) {
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:82:44: ^( ID $idVal)
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot(stream_ID.nextNode(), root_2);

                    adaptor.addChild(root_2, stream_idVal.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_idVal.reset();
                stream_ID.reset();
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:82:59: ( dependsOn )?
                if ( stream_dependsOn.hasNext() ) {
                    adaptor.addChild(root_1, stream_dependsOn.nextTree());

                }
                stream_dependsOn.reset();
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:82:70: ( imports )?
                if ( stream_imports.hasNext() ) {
                    adaptor.addChild(root_1, stream_imports.nextTree());

                }
                stream_imports.reset();
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:83:5: ( alias )?
                if ( stream_alias.hasNext() ) {
                    adaptor.addChild(root_1, stream_alias.nextTree());

                }
                stream_alias.reset();
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:83:12: ( nodes )?
                if ( stream_nodes.hasNext() ) {
                    adaptor.addChild(root_1, stream_nodes.nextTree());

                }
                stream_nodes.reset();
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:83:19: ( graph )?
                if ( stream_graph.hasNext() ) {
                    adaptor.addChild(root_1, stream_graph.nextTree());

                }
                stream_graph.reset();
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:83:26: ( where )?
                if ( stream_where.hasNext() ) {
                    adaptor.addChild(root_1, stream_where.nextTree());

                }
                stream_where.reset();
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:83:33: ( parameters )?
                if ( stream_parameters.hasNext() ) {
                    adaptor.addChild(root_1, stream_parameters.nextTree());

                }
                stream_parameters.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "prRule"

    public static class dependsOn_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "dependsOn"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:87:1: dependsOn : DependsOn ( dependency ( ',' )? )+ -> ^( DependsOn ( dependency )+ ) ;
    public final AntlrParser.dependsOn_return dependsOn() throws RecognitionException {
        AntlrParser.dependsOn_return retval = new AntlrParser.dependsOn_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token DependsOn22=null;
        Token char_literal24=null;
        AntlrParser.dependency_return dependency23 = null;


        Object DependsOn22_tree=null;
        Object char_literal24_tree=null;
        RewriteRuleTokenStream stream_69=new RewriteRuleTokenStream(adaptor,"token 69");
        RewriteRuleTokenStream stream_DependsOn=new RewriteRuleTokenStream(adaptor,"token DependsOn");
        RewriteRuleSubtreeStream stream_dependency=new RewriteRuleSubtreeStream(adaptor,"rule dependency");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:88:2: ( DependsOn ( dependency ( ',' )? )+ -> ^( DependsOn ( dependency )+ ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:88:5: DependsOn ( dependency ( ',' )? )+
            {
            DependsOn22=(Token)match(input,DependsOn,FOLLOW_DependsOn_in_dependsOn263);  
            stream_DependsOn.add(DependsOn22);

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:88:15: ( dependency ( ',' )? )+
            int cnt14=0;
            loop14:
            do {
                int alt14=2;
                int LA14_0 = input.LA(1);

                if ( ((LA14_0>=DependType1 && LA14_0<=DependTypeMult)) ) {
                    alt14=1;
                }


                switch (alt14) {
            	case 1 :
            	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:88:16: dependency ( ',' )?
            	    {
            	    pushFollow(FOLLOW_dependency_in_dependsOn266);
            	    dependency23=dependency();

            	    state._fsp--;

            	    stream_dependency.add(dependency23.getTree());
            	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:88:27: ( ',' )?
            	    int alt13=2;
            	    int LA13_0 = input.LA(1);

            	    if ( (LA13_0==69) ) {
            	        alt13=1;
            	    }
            	    switch (alt13) {
            	        case 1 :
            	            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:88:27: ','
            	            {
            	            char_literal24=(Token)match(input,69,FOLLOW_69_in_dependsOn268);  
            	            stream_69.add(char_literal24);


            	            }
            	            break;

            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt14 >= 1 ) break loop14;
                        EarlyExitException eee =
                            new EarlyExitException(14, input);
                        throw eee;
                }
                cnt14++;
            } while (true);



            // AST REWRITE
            // elements: dependency, DependsOn
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 88:35: -> ^( DependsOn ( dependency )+ )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:88:38: ^( DependsOn ( dependency )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_DependsOn.nextNode(), root_1);

                if ( !(stream_dependency.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_dependency.hasNext() ) {
                    adaptor.addChild(root_1, stream_dependency.nextTree());

                }
                stream_dependency.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "dependsOn"

    public static class imports_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "imports"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:91:1: imports : Imports ( dependency ( ',' )? )+ -> ^( Imports ( dependency )+ ) ;
    public final AntlrParser.imports_return imports() throws RecognitionException {
        AntlrParser.imports_return retval = new AntlrParser.imports_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token Imports25=null;
        Token char_literal27=null;
        AntlrParser.dependency_return dependency26 = null;


        Object Imports25_tree=null;
        Object char_literal27_tree=null;
        RewriteRuleTokenStream stream_69=new RewriteRuleTokenStream(adaptor,"token 69");
        RewriteRuleTokenStream stream_Imports=new RewriteRuleTokenStream(adaptor,"token Imports");
        RewriteRuleSubtreeStream stream_dependency=new RewriteRuleSubtreeStream(adaptor,"rule dependency");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:92:2: ( Imports ( dependency ( ',' )? )+ -> ^( Imports ( dependency )+ ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:92:5: Imports ( dependency ( ',' )? )+
            {
            Imports25=(Token)match(input,Imports,FOLLOW_Imports_in_imports294);  
            stream_Imports.add(Imports25);

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:92:13: ( dependency ( ',' )? )+
            int cnt16=0;
            loop16:
            do {
                int alt16=2;
                int LA16_0 = input.LA(1);

                if ( ((LA16_0>=DependType1 && LA16_0<=DependTypeMult)) ) {
                    alt16=1;
                }


                switch (alt16) {
            	case 1 :
            	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:92:14: dependency ( ',' )?
            	    {
            	    pushFollow(FOLLOW_dependency_in_imports297);
            	    dependency26=dependency();

            	    state._fsp--;

            	    stream_dependency.add(dependency26.getTree());
            	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:92:25: ( ',' )?
            	    int alt15=2;
            	    int LA15_0 = input.LA(1);

            	    if ( (LA15_0==69) ) {
            	        alt15=1;
            	    }
            	    switch (alt15) {
            	        case 1 :
            	            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:92:25: ','
            	            {
            	            char_literal27=(Token)match(input,69,FOLLOW_69_in_imports299);  
            	            stream_69.add(char_literal27);


            	            }
            	            break;

            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt16 >= 1 ) break loop16;
                        EarlyExitException eee =
                            new EarlyExitException(16, input);
                        throw eee;
                }
                cnt16++;
            } while (true);



            // AST REWRITE
            // elements: Imports, dependency
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 92:33: -> ^( Imports ( dependency )+ )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:92:36: ^( Imports ( dependency )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_Imports.nextNode(), root_1);

                if ( !(stream_dependency.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_dependency.hasNext() ) {
                    adaptor.addChild(root_1, stream_dependency.nextTree());

                }
                stream_dependency.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "imports"

    public static class dependency_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "dependency"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:95:1: dependency : ( DependType1 '(' idRule= word ')' -> ^( DependType1 $idRule) | DependType2 '(' idRule= word ',' uimaTypePR ')' -> ^( DependType2 $idRule uimaTypePR ) | DependType3 '(' idRule1= word ',' idRule2= word ',' idRule3= word ')' -> ^( DependType3 $idRule1 $idRule2 $idRule3) | DependTypeMult '(' idRule1= word ',' (idRuleMult= word ',' )+ idRule3= word ')' -> ^( DependTypeMult $idRule1 ( $idRuleMult)+ $idRule3) );
    public final AntlrParser.dependency_return dependency() throws RecognitionException {
        AntlrParser.dependency_return retval = new AntlrParser.dependency_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token DependType128=null;
        Token char_literal29=null;
        Token char_literal30=null;
        Token DependType231=null;
        Token char_literal32=null;
        Token char_literal33=null;
        Token char_literal35=null;
        Token DependType336=null;
        Token char_literal37=null;
        Token char_literal38=null;
        Token char_literal39=null;
        Token char_literal40=null;
        Token DependTypeMult41=null;
        Token char_literal42=null;
        Token char_literal43=null;
        Token char_literal44=null;
        Token char_literal45=null;
        AntlrParser.word_return idRule = null;

        AntlrParser.word_return idRule1 = null;

        AntlrParser.word_return idRule2 = null;

        AntlrParser.word_return idRule3 = null;

        AntlrParser.word_return idRuleMult = null;

        AntlrParser.uimaTypePR_return uimaTypePR34 = null;


        Object DependType128_tree=null;
        Object char_literal29_tree=null;
        Object char_literal30_tree=null;
        Object DependType231_tree=null;
        Object char_literal32_tree=null;
        Object char_literal33_tree=null;
        Object char_literal35_tree=null;
        Object DependType336_tree=null;
        Object char_literal37_tree=null;
        Object char_literal38_tree=null;
        Object char_literal39_tree=null;
        Object char_literal40_tree=null;
        Object DependTypeMult41_tree=null;
        Object char_literal42_tree=null;
        Object char_literal43_tree=null;
        Object char_literal44_tree=null;
        Object char_literal45_tree=null;
        RewriteRuleTokenStream stream_69=new RewriteRuleTokenStream(adaptor,"token 69");
        RewriteRuleTokenStream stream_DependType1=new RewriteRuleTokenStream(adaptor,"token DependType1");
        RewriteRuleTokenStream stream_DependTypeMult=new RewriteRuleTokenStream(adaptor,"token DependTypeMult");
        RewriteRuleTokenStream stream_DependType3=new RewriteRuleTokenStream(adaptor,"token DependType3");
        RewriteRuleTokenStream stream_DependType2=new RewriteRuleTokenStream(adaptor,"token DependType2");
        RewriteRuleTokenStream stream_70=new RewriteRuleTokenStream(adaptor,"token 70");
        RewriteRuleTokenStream stream_71=new RewriteRuleTokenStream(adaptor,"token 71");
        RewriteRuleSubtreeStream stream_word=new RewriteRuleSubtreeStream(adaptor,"rule word");
        RewriteRuleSubtreeStream stream_uimaTypePR=new RewriteRuleSubtreeStream(adaptor,"rule uimaTypePR");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:96:2: ( DependType1 '(' idRule= word ')' -> ^( DependType1 $idRule) | DependType2 '(' idRule= word ',' uimaTypePR ')' -> ^( DependType2 $idRule uimaTypePR ) | DependType3 '(' idRule1= word ',' idRule2= word ',' idRule3= word ')' -> ^( DependType3 $idRule1 $idRule2 $idRule3) | DependTypeMult '(' idRule1= word ',' (idRuleMult= word ',' )+ idRule3= word ')' -> ^( DependTypeMult $idRule1 ( $idRuleMult)+ $idRule3) )
            int alt18=4;
            switch ( input.LA(1) ) {
            case DependType1:
                {
                alt18=1;
                }
                break;
            case DependType2:
                {
                alt18=2;
                }
                break;
            case DependType3:
                {
                alt18=3;
                }
                break;
            case DependTypeMult:
                {
                alt18=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 18, 0, input);

                throw nvae;
            }

            switch (alt18) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:96:5: DependType1 '(' idRule= word ')'
                    {
                    DependType128=(Token)match(input,DependType1,FOLLOW_DependType1_in_dependency324);  
                    stream_DependType1.add(DependType128);

                    char_literal29=(Token)match(input,70,FOLLOW_70_in_dependency326);  
                    stream_70.add(char_literal29);

                    pushFollow(FOLLOW_word_in_dependency330);
                    idRule=word();

                    state._fsp--;

                    stream_word.add(idRule.getTree());
                    char_literal30=(Token)match(input,71,FOLLOW_71_in_dependency332);  
                    stream_71.add(char_literal30);



                    // AST REWRITE
                    // elements: idRule, DependType1
                    // token labels: 
                    // rule labels: retval, idRule
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
                    RewriteRuleSubtreeStream stream_idRule=new RewriteRuleSubtreeStream(adaptor,"rule idRule",idRule!=null?idRule.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 96:37: -> ^( DependType1 $idRule)
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:96:40: ^( DependType1 $idRule)
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(stream_DependType1.nextNode(), root_1);

                        adaptor.addChild(root_1, stream_idRule.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:97:5: DependType2 '(' idRule= word ',' uimaTypePR ')'
                    {
                    DependType231=(Token)match(input,DependType2,FOLLOW_DependType2_in_dependency347);  
                    stream_DependType2.add(DependType231);

                    char_literal32=(Token)match(input,70,FOLLOW_70_in_dependency349);  
                    stream_70.add(char_literal32);

                    pushFollow(FOLLOW_word_in_dependency353);
                    idRule=word();

                    state._fsp--;

                    stream_word.add(idRule.getTree());
                    char_literal33=(Token)match(input,69,FOLLOW_69_in_dependency355);  
                    stream_69.add(char_literal33);

                    pushFollow(FOLLOW_uimaTypePR_in_dependency357);
                    uimaTypePR34=uimaTypePR();

                    state._fsp--;

                    stream_uimaTypePR.add(uimaTypePR34.getTree());
                    char_literal35=(Token)match(input,71,FOLLOW_71_in_dependency359);  
                    stream_71.add(char_literal35);



                    // AST REWRITE
                    // elements: idRule, DependType2, uimaTypePR
                    // token labels: 
                    // rule labels: retval, idRule
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
                    RewriteRuleSubtreeStream stream_idRule=new RewriteRuleSubtreeStream(adaptor,"rule idRule",idRule!=null?idRule.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 97:52: -> ^( DependType2 $idRule uimaTypePR )
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:97:55: ^( DependType2 $idRule uimaTypePR )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(stream_DependType2.nextNode(), root_1);

                        adaptor.addChild(root_1, stream_idRule.nextTree());
                        adaptor.addChild(root_1, stream_uimaTypePR.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 3 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:98:5: DependType3 '(' idRule1= word ',' idRule2= word ',' idRule3= word ')'
                    {
                    DependType336=(Token)match(input,DependType3,FOLLOW_DependType3_in_dependency376);  
                    stream_DependType3.add(DependType336);

                    char_literal37=(Token)match(input,70,FOLLOW_70_in_dependency378);  
                    stream_70.add(char_literal37);

                    pushFollow(FOLLOW_word_in_dependency382);
                    idRule1=word();

                    state._fsp--;

                    stream_word.add(idRule1.getTree());
                    char_literal38=(Token)match(input,69,FOLLOW_69_in_dependency384);  
                    stream_69.add(char_literal38);

                    pushFollow(FOLLOW_word_in_dependency388);
                    idRule2=word();

                    state._fsp--;

                    stream_word.add(idRule2.getTree());
                    char_literal39=(Token)match(input,69,FOLLOW_69_in_dependency390);  
                    stream_69.add(char_literal39);

                    pushFollow(FOLLOW_word_in_dependency395);
                    idRule3=word();

                    state._fsp--;

                    stream_word.add(idRule3.getTree());
                    char_literal40=(Token)match(input,71,FOLLOW_71_in_dependency397);  
                    stream_71.add(char_literal40);



                    // AST REWRITE
                    // elements: idRule3, idRule2, DependType3, idRule1
                    // token labels: 
                    // rule labels: idRule3, retval, idRule1, idRule2
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_idRule3=new RewriteRuleSubtreeStream(adaptor,"rule idRule3",idRule3!=null?idRule3.tree:null);
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
                    RewriteRuleSubtreeStream stream_idRule1=new RewriteRuleSubtreeStream(adaptor,"rule idRule1",idRule1!=null?idRule1.tree:null);
                    RewriteRuleSubtreeStream stream_idRule2=new RewriteRuleSubtreeStream(adaptor,"rule idRule2",idRule2!=null?idRule2.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 98:73: -> ^( DependType3 $idRule1 $idRule2 $idRule3)
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:98:76: ^( DependType3 $idRule1 $idRule2 $idRule3)
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(stream_DependType3.nextNode(), root_1);

                        adaptor.addChild(root_1, stream_idRule1.nextTree());
                        adaptor.addChild(root_1, stream_idRule2.nextTree());
                        adaptor.addChild(root_1, stream_idRule3.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 4 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:99:5: DependTypeMult '(' idRule1= word ',' (idRuleMult= word ',' )+ idRule3= word ')'
                    {
                    DependTypeMult41=(Token)match(input,DependTypeMult,FOLLOW_DependTypeMult_in_dependency418);  
                    stream_DependTypeMult.add(DependTypeMult41);

                    char_literal42=(Token)match(input,70,FOLLOW_70_in_dependency420);  
                    stream_70.add(char_literal42);

                    pushFollow(FOLLOW_word_in_dependency424);
                    idRule1=word();

                    state._fsp--;

                    stream_word.add(idRule1.getTree());
                    char_literal43=(Token)match(input,69,FOLLOW_69_in_dependency426);  
                    stream_69.add(char_literal43);

                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:99:41: (idRuleMult= word ',' )+
                    int cnt17=0;
                    loop17:
                    do {
                        int alt17=2;
                        switch ( input.LA(1) ) {
                        case SmallWord:
                            {
                            int LA17_1 = input.LA(2);

                            if ( (LA17_1==69) ) {
                                alt17=1;
                            }


                            }
                            break;
                        case CapitalWord:
                            {
                            int LA17_2 = input.LA(2);

                            if ( (LA17_2==69) ) {
                                alt17=1;
                            }


                            }
                            break;
                        case Number:
                            {
                            switch ( input.LA(2) ) {
                            case 85:
                            case 89:
                                {
                                int LA17_7 = input.LA(3);

                                if ( ((LA17_7>=SmallWord && LA17_7<=CapitalWord)) ) {
                                    int LA17_8 = input.LA(4);

                                    if ( (LA17_8==69) ) {
                                        alt17=1;
                                    }


                                }


                                }
                                break;
                            case SmallWord:
                            case CapitalWord:
                                {
                                int LA17_8 = input.LA(3);

                                if ( (LA17_8==69) ) {
                                    alt17=1;
                                }


                                }
                                break;
                            case 69:
                                {
                                alt17=1;
                                }
                                break;

                            }

                            }
                            break;
                        case Conf:
                            {
                            int LA17_4 = input.LA(2);

                            if ( (LA17_4==69) ) {
                                alt17=1;
                            }


                            }
                            break;

                        }

                        switch (alt17) {
                    	case 1 :
                    	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:99:42: idRuleMult= word ','
                    	    {
                    	    pushFollow(FOLLOW_word_in_dependency431);
                    	    idRuleMult=word();

                    	    state._fsp--;

                    	    stream_word.add(idRuleMult.getTree());
                    	    char_literal44=(Token)match(input,69,FOLLOW_69_in_dependency433);  
                    	    stream_69.add(char_literal44);


                    	    }
                    	    break;

                    	default :
                    	    if ( cnt17 >= 1 ) break loop17;
                                EarlyExitException eee =
                                    new EarlyExitException(17, input);
                                throw eee;
                        }
                        cnt17++;
                    } while (true);

                    pushFollow(FOLLOW_word_in_dependency440);
                    idRule3=word();

                    state._fsp--;

                    stream_word.add(idRule3.getTree());
                    char_literal45=(Token)match(input,71,FOLLOW_71_in_dependency442);  
                    stream_71.add(char_literal45);



                    // AST REWRITE
                    // elements: idRule3, idRule1, idRuleMult, DependTypeMult
                    // token labels: 
                    // rule labels: idRule3, retval, idRule1, idRuleMult
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_idRule3=new RewriteRuleSubtreeStream(adaptor,"rule idRule3",idRule3!=null?idRule3.tree:null);
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
                    RewriteRuleSubtreeStream stream_idRule1=new RewriteRuleSubtreeStream(adaptor,"rule idRule1",idRule1!=null?idRule1.tree:null);
                    RewriteRuleSubtreeStream stream_idRuleMult=new RewriteRuleSubtreeStream(adaptor,"rule idRuleMult",idRuleMult!=null?idRuleMult.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 99:82: -> ^( DependTypeMult $idRule1 ( $idRuleMult)+ $idRule3)
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:99:85: ^( DependTypeMult $idRule1 ( $idRuleMult)+ $idRule3)
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(stream_DependTypeMult.nextNode(), root_1);

                        adaptor.addChild(root_1, stream_idRule1.nextTree());
                        if ( !(stream_idRuleMult.hasNext()) ) {
                            throw new RewriteEarlyExitException();
                        }
                        while ( stream_idRuleMult.hasNext() ) {
                            adaptor.addChild(root_1, stream_idRuleMult.nextTree());

                        }
                        stream_idRuleMult.reset();
                        adaptor.addChild(root_1, stream_idRule3.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "dependency"

    public static class alias_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "alias"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:104:1: alias : ( ALIAS '=' '{' ( singleAlias )+ '}' -> ^( ALIAS ( singleAlias )+ ) | ALIAS '=' '{' '}' -> NOALIAS );
    public final AntlrParser.alias_return alias() throws RecognitionException {
        AntlrParser.alias_return retval = new AntlrParser.alias_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token ALIAS46=null;
        Token char_literal47=null;
        Token char_literal48=null;
        Token char_literal50=null;
        Token ALIAS51=null;
        Token char_literal52=null;
        Token char_literal53=null;
        Token char_literal54=null;
        AntlrParser.singleAlias_return singleAlias49 = null;


        Object ALIAS46_tree=null;
        Object char_literal47_tree=null;
        Object char_literal48_tree=null;
        Object char_literal50_tree=null;
        Object ALIAS51_tree=null;
        Object char_literal52_tree=null;
        Object char_literal53_tree=null;
        Object char_literal54_tree=null;
        RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
        RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68");
        RewriteRuleTokenStream stream_64=new RewriteRuleTokenStream(adaptor,"token 64");
        RewriteRuleTokenStream stream_ALIAS=new RewriteRuleTokenStream(adaptor,"token ALIAS");
        RewriteRuleSubtreeStream stream_singleAlias=new RewriteRuleSubtreeStream(adaptor,"rule singleAlias");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:105:2: ( ALIAS '=' '{' ( singleAlias )+ '}' -> ^( ALIAS ( singleAlias )+ ) | ALIAS '=' '{' '}' -> NOALIAS )
            int alt20=2;
            int LA20_0 = input.LA(1);

            if ( (LA20_0==ALIAS) ) {
                int LA20_1 = input.LA(2);

                if ( (LA20_1==64) ) {
                    int LA20_2 = input.LA(3);

                    if ( (LA20_2==67) ) {
                        int LA20_3 = input.LA(4);

                        if ( (LA20_3==68) ) {
                            alt20=2;
                        }
                        else if ( (LA20_3==Conf||(LA20_3>=SmallWord && LA20_3<=Number)) ) {
                            alt20=1;
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 20, 3, input);

                            throw nvae;
                        }
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 20, 2, input);

                        throw nvae;
                    }
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 20, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 20, 0, input);

                throw nvae;
            }
            switch (alt20) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:105:5: ALIAS '=' '{' ( singleAlias )+ '}'
                    {
                    ALIAS46=(Token)match(input,ALIAS,FOLLOW_ALIAS_in_alias473);  
                    stream_ALIAS.add(ALIAS46);

                    char_literal47=(Token)match(input,64,FOLLOW_64_in_alias475);  
                    stream_64.add(char_literal47);

                    char_literal48=(Token)match(input,67,FOLLOW_67_in_alias477);  
                    stream_67.add(char_literal48);

                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:105:19: ( singleAlias )+
                    int cnt19=0;
                    loop19:
                    do {
                        int alt19=2;
                        int LA19_0 = input.LA(1);

                        if ( (LA19_0==Conf||(LA19_0>=SmallWord && LA19_0<=Number)) ) {
                            alt19=1;
                        }


                        switch (alt19) {
                    	case 1 :
                    	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:105:19: singleAlias
                    	    {
                    	    pushFollow(FOLLOW_singleAlias_in_alias479);
                    	    singleAlias49=singleAlias();

                    	    state._fsp--;

                    	    stream_singleAlias.add(singleAlias49.getTree());

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt19 >= 1 ) break loop19;
                                EarlyExitException eee =
                                    new EarlyExitException(19, input);
                                throw eee;
                        }
                        cnt19++;
                    } while (true);

                    char_literal50=(Token)match(input,68,FOLLOW_68_in_alias482);  
                    stream_68.add(char_literal50);



                    // AST REWRITE
                    // elements: ALIAS, singleAlias
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 105:36: -> ^( ALIAS ( singleAlias )+ )
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:105:39: ^( ALIAS ( singleAlias )+ )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(stream_ALIAS.nextNode(), root_1);

                        if ( !(stream_singleAlias.hasNext()) ) {
                            throw new RewriteEarlyExitException();
                        }
                        while ( stream_singleAlias.hasNext() ) {
                            adaptor.addChild(root_1, stream_singleAlias.nextTree());

                        }
                        stream_singleAlias.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:106:5: ALIAS '=' '{' '}'
                    {
                    ALIAS51=(Token)match(input,ALIAS,FOLLOW_ALIAS_in_alias497);  
                    stream_ALIAS.add(ALIAS51);

                    char_literal52=(Token)match(input,64,FOLLOW_64_in_alias499);  
                    stream_64.add(char_literal52);

                    char_literal53=(Token)match(input,67,FOLLOW_67_in_alias501);  
                    stream_67.add(char_literal53);

                    char_literal54=(Token)match(input,68,FOLLOW_68_in_alias503);  
                    stream_68.add(char_literal54);



                    // AST REWRITE
                    // elements: 
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 106:23: -> NOALIAS
                    {
                        adaptor.addChild(root_0, (Object)adaptor.create(NOALIAS, "NOALIAS"));

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "alias"

    public static class singleAlias_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "singleAlias"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:109:1: singleAlias : idAlias= word uimaTypeAndFeats -> ^( SINGLEALIAS ^( ID $idAlias) uimaTypeAndFeats ) ;
    public final AntlrParser.singleAlias_return singleAlias() throws RecognitionException {
        AntlrParser.singleAlias_return retval = new AntlrParser.singleAlias_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AntlrParser.word_return idAlias = null;

        AntlrParser.uimaTypeAndFeats_return uimaTypeAndFeats55 = null;


        RewriteRuleSubtreeStream stream_uimaTypeAndFeats=new RewriteRuleSubtreeStream(adaptor,"rule uimaTypeAndFeats");
        RewriteRuleSubtreeStream stream_word=new RewriteRuleSubtreeStream(adaptor,"rule word");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:110:2: (idAlias= word uimaTypeAndFeats -> ^( SINGLEALIAS ^( ID $idAlias) uimaTypeAndFeats ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:110:5: idAlias= word uimaTypeAndFeats
            {
            pushFollow(FOLLOW_word_in_singleAlias522);
            idAlias=word();

            state._fsp--;

            stream_word.add(idAlias.getTree());
            pushFollow(FOLLOW_uimaTypeAndFeats_in_singleAlias524);
            uimaTypeAndFeats55=uimaTypeAndFeats();

            state._fsp--;

            stream_uimaTypeAndFeats.add(uimaTypeAndFeats55.getTree());


            // AST REWRITE
            // elements: idAlias, uimaTypeAndFeats
            // token labels: 
            // rule labels: retval, idAlias
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
            RewriteRuleSubtreeStream stream_idAlias=new RewriteRuleSubtreeStream(adaptor,"rule idAlias",idAlias!=null?idAlias.tree:null);

            root_0 = (Object)adaptor.nil();
            // 111:4: -> ^( SINGLEALIAS ^( ID $idAlias) uimaTypeAndFeats )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:111:7: ^( SINGLEALIAS ^( ID $idAlias) uimaTypeAndFeats )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(SINGLEALIAS, "SINGLEALIAS"), root_1);

                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:111:21: ^( ID $idAlias)
                {
                Object root_2 = (Object)adaptor.nil();
                root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(ID, "ID"), root_2);

                adaptor.addChild(root_2, stream_idAlias.nextTree());

                adaptor.addChild(root_1, root_2);
                }
                adaptor.addChild(root_1, stream_uimaTypeAndFeats.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "singleAlias"

    public static class nodes_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "nodes"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:115:1: nodes : ( NODES '=' '{' ( node )+ '}' -> ^( NODES ( node )+ ) | NODES '=' '{' '}' -> NONODE );
    public final AntlrParser.nodes_return nodes() throws RecognitionException {
        AntlrParser.nodes_return retval = new AntlrParser.nodes_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token NODES56=null;
        Token char_literal57=null;
        Token char_literal58=null;
        Token char_literal60=null;
        Token NODES61=null;
        Token char_literal62=null;
        Token char_literal63=null;
        Token char_literal64=null;
        AntlrParser.node_return node59 = null;


        Object NODES56_tree=null;
        Object char_literal57_tree=null;
        Object char_literal58_tree=null;
        Object char_literal60_tree=null;
        Object NODES61_tree=null;
        Object char_literal62_tree=null;
        Object char_literal63_tree=null;
        Object char_literal64_tree=null;
        RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
        RewriteRuleTokenStream stream_NODES=new RewriteRuleTokenStream(adaptor,"token NODES");
        RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68");
        RewriteRuleTokenStream stream_64=new RewriteRuleTokenStream(adaptor,"token 64");
        RewriteRuleSubtreeStream stream_node=new RewriteRuleSubtreeStream(adaptor,"rule node");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:116:2: ( NODES '=' '{' ( node )+ '}' -> ^( NODES ( node )+ ) | NODES '=' '{' '}' -> NONODE )
            int alt22=2;
            int LA22_0 = input.LA(1);

            if ( (LA22_0==NODES) ) {
                int LA22_1 = input.LA(2);

                if ( (LA22_1==64) ) {
                    int LA22_2 = input.LA(3);

                    if ( (LA22_2==67) ) {
                        int LA22_3 = input.LA(4);

                        if ( (LA22_3==68) ) {
                            alt22=2;
                        }
                        else if ( (LA22_3==Conf||(LA22_3>=SmallWord && LA22_3<=Number)) ) {
                            alt22=1;
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 22, 3, input);

                            throw nvae;
                        }
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 22, 2, input);

                        throw nvae;
                    }
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 22, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 22, 0, input);

                throw nvae;
            }
            switch (alt22) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:116:5: NODES '=' '{' ( node )+ '}'
                    {
                    NODES56=(Token)match(input,NODES,FOLLOW_NODES_in_nodes555);  
                    stream_NODES.add(NODES56);

                    char_literal57=(Token)match(input,64,FOLLOW_64_in_nodes557);  
                    stream_64.add(char_literal57);

                    char_literal58=(Token)match(input,67,FOLLOW_67_in_nodes559);  
                    stream_67.add(char_literal58);

                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:116:19: ( node )+
                    int cnt21=0;
                    loop21:
                    do {
                        int alt21=2;
                        int LA21_0 = input.LA(1);

                        if ( (LA21_0==Conf||(LA21_0>=SmallWord && LA21_0<=Number)) ) {
                            alt21=1;
                        }


                        switch (alt21) {
                    	case 1 :
                    	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:116:19: node
                    	    {
                    	    pushFollow(FOLLOW_node_in_nodes561);
                    	    node59=node();

                    	    state._fsp--;

                    	    stream_node.add(node59.getTree());

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt21 >= 1 ) break loop21;
                                EarlyExitException eee =
                                    new EarlyExitException(21, input);
                                throw eee;
                        }
                        cnt21++;
                    } while (true);

                    char_literal60=(Token)match(input,68,FOLLOW_68_in_nodes564);  
                    stream_68.add(char_literal60);



                    // AST REWRITE
                    // elements: node, NODES
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 116:29: -> ^( NODES ( node )+ )
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:116:32: ^( NODES ( node )+ )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(stream_NODES.nextNode(), root_1);

                        if ( !(stream_node.hasNext()) ) {
                            throw new RewriteEarlyExitException();
                        }
                        while ( stream_node.hasNext() ) {
                            adaptor.addChild(root_1, stream_node.nextTree());

                        }
                        stream_node.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:117:5: NODES '=' '{' '}'
                    {
                    NODES61=(Token)match(input,NODES,FOLLOW_NODES_in_nodes579);  
                    stream_NODES.add(NODES61);

                    char_literal62=(Token)match(input,64,FOLLOW_64_in_nodes581);  
                    stream_64.add(char_literal62);

                    char_literal63=(Token)match(input,67,FOLLOW_67_in_nodes583);  
                    stream_67.add(char_literal63);

                    char_literal64=(Token)match(input,68,FOLLOW_68_in_nodes585);  
                    stream_68.add(char_literal64);



                    // AST REWRITE
                    // elements: 
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 117:23: -> NONODE
                    {
                        adaptor.addChild(root_0, (Object)adaptor.create(NONODE, "NONODE"));

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "nodes"

    public static class node_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "node"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:120:1: node : (idNode= word type= projType uimaTypeAndFeats -> ^( NODE ^( ID $idNode) ^( TYPE $type) uimaTypeAndFeats ) | idNode= word type= projType condIf -> ^( NODE ^( ID $idNode) ^( TYPE $type) condIf ) );
    public final AntlrParser.node_return node() throws RecognitionException {
        AntlrParser.node_return retval = new AntlrParser.node_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AntlrParser.word_return idNode = null;

        AntlrParser.projType_return type = null;

        AntlrParser.uimaTypeAndFeats_return uimaTypeAndFeats65 = null;

        AntlrParser.condIf_return condIf66 = null;


        RewriteRuleSubtreeStream stream_uimaTypeAndFeats=new RewriteRuleSubtreeStream(adaptor,"rule uimaTypeAndFeats");
        RewriteRuleSubtreeStream stream_word=new RewriteRuleSubtreeStream(adaptor,"rule word");
        RewriteRuleSubtreeStream stream_condIf=new RewriteRuleSubtreeStream(adaptor,"rule condIf");
        RewriteRuleSubtreeStream stream_projType=new RewriteRuleSubtreeStream(adaptor,"rule projType");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:121:2: (idNode= word type= projType uimaTypeAndFeats -> ^( NODE ^( ID $idNode) ^( TYPE $type) uimaTypeAndFeats ) | idNode= word type= projType condIf -> ^( NODE ^( ID $idNode) ^( TYPE $type) condIf ) )
            int alt23=2;
            alt23 = dfa23.predict(input);
            switch (alt23) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:121:5: idNode= word type= projType uimaTypeAndFeats
                    {
                    pushFollow(FOLLOW_word_in_node603);
                    idNode=word();

                    state._fsp--;

                    stream_word.add(idNode.getTree());
                    pushFollow(FOLLOW_projType_in_node607);
                    type=projType();

                    state._fsp--;

                    stream_projType.add(type.getTree());
                    pushFollow(FOLLOW_uimaTypeAndFeats_in_node609);
                    uimaTypeAndFeats65=uimaTypeAndFeats();

                    state._fsp--;

                    stream_uimaTypeAndFeats.add(uimaTypeAndFeats65.getTree());


                    // AST REWRITE
                    // elements: uimaTypeAndFeats, type, idNode
                    // token labels: 
                    // rule labels: retval, idNode, type
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
                    RewriteRuleSubtreeStream stream_idNode=new RewriteRuleSubtreeStream(adaptor,"rule idNode",idNode!=null?idNode.tree:null);
                    RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type",type!=null?type.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 122:4: -> ^( NODE ^( ID $idNode) ^( TYPE $type) uimaTypeAndFeats )
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:122:7: ^( NODE ^( ID $idNode) ^( TYPE $type) uimaTypeAndFeats )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(NODE, "NODE"), root_1);

                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:122:14: ^( ID $idNode)
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(ID, "ID"), root_2);

                        adaptor.addChild(root_2, stream_idNode.nextTree());

                        adaptor.addChild(root_1, root_2);
                        }
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:122:28: ^( TYPE $type)
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(TYPE, "TYPE"), root_2);

                        adaptor.addChild(root_2, stream_type.nextTree());

                        adaptor.addChild(root_1, root_2);
                        }
                        adaptor.addChild(root_1, stream_uimaTypeAndFeats.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:123:5: idNode= word type= projType condIf
                    {
                    pushFollow(FOLLOW_word_in_node643);
                    idNode=word();

                    state._fsp--;

                    stream_word.add(idNode.getTree());
                    pushFollow(FOLLOW_projType_in_node647);
                    type=projType();

                    state._fsp--;

                    stream_projType.add(type.getTree());
                    pushFollow(FOLLOW_condIf_in_node649);
                    condIf66=condIf();

                    state._fsp--;

                    stream_condIf.add(condIf66.getTree());


                    // AST REWRITE
                    // elements: idNode, condIf, type
                    // token labels: 
                    // rule labels: retval, type, idNode
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
                    RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type",type!=null?type.tree:null);
                    RewriteRuleSubtreeStream stream_idNode=new RewriteRuleSubtreeStream(adaptor,"rule idNode",idNode!=null?idNode.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 124:4: -> ^( NODE ^( ID $idNode) ^( TYPE $type) condIf )
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:124:7: ^( NODE ^( ID $idNode) ^( TYPE $type) condIf )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(NODE, "NODE"), root_1);

                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:124:14: ^( ID $idNode)
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(ID, "ID"), root_2);

                        adaptor.addChild(root_2, stream_idNode.nextTree());

                        adaptor.addChild(root_1, root_2);
                        }
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:124:28: ^( TYPE $type)
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(TYPE, "TYPE"), root_2);

                        adaptor.addChild(root_2, stream_type.nextTree());

                        adaptor.addChild(root_1, root_2);
                        }
                        adaptor.addChild(root_1, stream_condIf.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "node"

    public static class projType_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "projType"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:127:1: projType : ( 'uri' | ( 'plainLiteral' ( lang )? ) | ( 'literal' ( '(' LITERALTYPE ')' ) ) ) ;
    public final AntlrParser.projType_return projType() throws RecognitionException {
        AntlrParser.projType_return retval = new AntlrParser.projType_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token string_literal67=null;
        Token string_literal68=null;
        Token string_literal70=null;
        Token char_literal71=null;
        Token LITERALTYPE72=null;
        Token char_literal73=null;
        AntlrParser.lang_return lang69 = null;


        Object string_literal67_tree=null;
        Object string_literal68_tree=null;
        Object string_literal70_tree=null;
        Object char_literal71_tree=null;
        Object LITERALTYPE72_tree=null;
        Object char_literal73_tree=null;

        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:2: ( ( 'uri' | ( 'plainLiteral' ( lang )? ) | ( 'literal' ( '(' LITERALTYPE ')' ) ) ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:5: ( 'uri' | ( 'plainLiteral' ( lang )? ) | ( 'literal' ( '(' LITERALTYPE ')' ) ) )
            {
            root_0 = (Object)adaptor.nil();

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:5: ( 'uri' | ( 'plainLiteral' ( lang )? ) | ( 'literal' ( '(' LITERALTYPE ')' ) ) )
            int alt25=3;
            switch ( input.LA(1) ) {
            case 72:
                {
                alt25=1;
                }
                break;
            case 73:
                {
                alt25=2;
                }
                break;
            case 74:
                {
                alt25=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 25, 0, input);

                throw nvae;
            }

            switch (alt25) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:6: 'uri'
                    {
                    string_literal67=(Token)match(input,72,FOLLOW_72_in_projType689); 
                    string_literal67_tree = (Object)adaptor.create(string_literal67);
                    adaptor.addChild(root_0, string_literal67_tree);


                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:12: ( 'plainLiteral' ( lang )? )
                    {
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:12: ( 'plainLiteral' ( lang )? )
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:13: 'plainLiteral' ( lang )?
                    {
                    string_literal68=(Token)match(input,73,FOLLOW_73_in_projType692); 
                    string_literal68_tree = (Object)adaptor.create(string_literal68);
                    adaptor.addChild(root_0, string_literal68_tree);

                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:27: ( lang )?
                    int alt24=2;
                    int LA24_0 = input.LA(1);

                    if ( (LA24_0==70) ) {
                        alt24=1;
                    }
                    switch (alt24) {
                        case 1 :
                            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:28: lang
                            {
                            pushFollow(FOLLOW_lang_in_projType694);
                            lang69=lang();

                            state._fsp--;

                            adaptor.addChild(root_0, lang69.getTree());

                            }
                            break;

                    }


                    }


                    }
                    break;
                case 3 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:36: ( 'literal' ( '(' LITERALTYPE ')' ) )
                    {
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:36: ( 'literal' ( '(' LITERALTYPE ')' ) )
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:37: 'literal' ( '(' LITERALTYPE ')' )
                    {
                    string_literal70=(Token)match(input,74,FOLLOW_74_in_projType700); 
                    string_literal70_tree = (Object)adaptor.create(string_literal70);
                    adaptor.addChild(root_0, string_literal70_tree);

                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:47: ( '(' LITERALTYPE ')' )
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:128:48: '(' LITERALTYPE ')'
                    {
                    char_literal71=(Token)match(input,70,FOLLOW_70_in_projType703); 
                    char_literal71_tree = (Object)adaptor.create(char_literal71);
                    adaptor.addChild(root_0, char_literal71_tree);

                    LITERALTYPE72=(Token)match(input,LITERALTYPE,FOLLOW_LITERALTYPE_in_projType705); 
                    LITERALTYPE72_tree = (Object)adaptor.create(LITERALTYPE72);
                    adaptor.addChild(root_0, LITERALTYPE72_tree);

                    char_literal73=(Token)match(input,71,FOLLOW_71_in_projType707); 
                    char_literal73_tree = (Object)adaptor.create(char_literal73);
                    adaptor.addChild(root_0, char_literal73_tree);


                    }


                    }


                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "projType"

    public static class lang_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "lang"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:131:1: lang : '(' word ')' ;
    public final AntlrParser.lang_return lang() throws RecognitionException {
        AntlrParser.lang_return retval = new AntlrParser.lang_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal74=null;
        Token char_literal76=null;
        AntlrParser.word_return word75 = null;


        Object char_literal74_tree=null;
        Object char_literal76_tree=null;

        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:131:5: ( '(' word ')' )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:131:7: '(' word ')'
            {
            root_0 = (Object)adaptor.nil();

            char_literal74=(Token)match(input,70,FOLLOW_70_in_lang720); 
            char_literal74_tree = (Object)adaptor.create(char_literal74);
            adaptor.addChild(root_0, char_literal74_tree);

            pushFollow(FOLLOW_word_in_lang722);
            word75=word();

            state._fsp--;

            adaptor.addChild(root_0, word75.getTree());
            char_literal76=(Token)match(input,71,FOLLOW_71_in_lang724); 
            char_literal76_tree = (Object)adaptor.create(char_literal76);
            adaptor.addChild(root_0, char_literal76_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "lang"

    public static class nodeIfElseValue_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "nodeIfElseValue"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:134:1: nodeIfElseValue : ( uimaTypeAndFeats -> uimaTypeAndFeats | ontClass -> ^( ONTORES ontClass ) | ontProperty -> ^( ONTORES ontProperty ) );
    public final AntlrParser.nodeIfElseValue_return nodeIfElseValue() throws RecognitionException {
        AntlrParser.nodeIfElseValue_return retval = new AntlrParser.nodeIfElseValue_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AntlrParser.uimaTypeAndFeats_return uimaTypeAndFeats77 = null;

        AntlrParser.ontClass_return ontClass78 = null;

        AntlrParser.ontProperty_return ontProperty79 = null;


        RewriteRuleSubtreeStream stream_uimaTypeAndFeats=new RewriteRuleSubtreeStream(adaptor,"rule uimaTypeAndFeats");
        RewriteRuleSubtreeStream stream_ontClass=new RewriteRuleSubtreeStream(adaptor,"rule ontClass");
        RewriteRuleSubtreeStream stream_ontProperty=new RewriteRuleSubtreeStream(adaptor,"rule ontProperty");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:135:2: ( uimaTypeAndFeats -> uimaTypeAndFeats | ontClass -> ^( ONTORES ontClass ) | ontProperty -> ^( ONTORES ontProperty ) )
            int alt26=3;
            alt26 = dfa26.predict(input);
            switch (alt26) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:135:5: uimaTypeAndFeats
                    {
                    pushFollow(FOLLOW_uimaTypeAndFeats_in_nodeIfElseValue735);
                    uimaTypeAndFeats77=uimaTypeAndFeats();

                    state._fsp--;

                    stream_uimaTypeAndFeats.add(uimaTypeAndFeats77.getTree());


                    // AST REWRITE
                    // elements: uimaTypeAndFeats
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 135:22: -> uimaTypeAndFeats
                    {
                        adaptor.addChild(root_0, stream_uimaTypeAndFeats.nextTree());

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:136:4: ontClass
                    {
                    pushFollow(FOLLOW_ontClass_in_nodeIfElseValue744);
                    ontClass78=ontClass();

                    state._fsp--;

                    stream_ontClass.add(ontClass78.getTree());


                    // AST REWRITE
                    // elements: ontClass
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 136:13: -> ^( ONTORES ontClass )
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:136:16: ^( ONTORES ontClass )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ONTORES, "ONTORES"), root_1);

                        adaptor.addChild(root_1, stream_ontClass.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 3 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:137:4: ontProperty
                    {
                    pushFollow(FOLLOW_ontProperty_in_nodeIfElseValue757);
                    ontProperty79=ontProperty();

                    state._fsp--;

                    stream_ontProperty.add(ontProperty79.getTree());


                    // AST REWRITE
                    // elements: ontProperty
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 137:16: -> ^( ONTORES ontProperty )
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:137:19: ^( ONTORES ontProperty )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ONTORES, "ONTORES"), root_1);

                        adaptor.addChild(root_1, stream_ontProperty.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "nodeIfElseValue"

    public static class condIf_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "condIf"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:140:1: condIf : IF condValueAndUIMAType ( condElseIf )* ( condElse )? -> ^( COND ^( IF condValueAndUIMAType ) ( condElseIf )* ( condElse )? ) ;
    public final AntlrParser.condIf_return condIf() throws RecognitionException {
        AntlrParser.condIf_return retval = new AntlrParser.condIf_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token IF80=null;
        AntlrParser.condValueAndUIMAType_return condValueAndUIMAType81 = null;

        AntlrParser.condElseIf_return condElseIf82 = null;

        AntlrParser.condElse_return condElse83 = null;


        Object IF80_tree=null;
        RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
        RewriteRuleSubtreeStream stream_condValueAndUIMAType=new RewriteRuleSubtreeStream(adaptor,"rule condValueAndUIMAType");
        RewriteRuleSubtreeStream stream_condElseIf=new RewriteRuleSubtreeStream(adaptor,"rule condElseIf");
        RewriteRuleSubtreeStream stream_condElse=new RewriteRuleSubtreeStream(adaptor,"rule condElse");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:141:2: ( IF condValueAndUIMAType ( condElseIf )* ( condElse )? -> ^( COND ^( IF condValueAndUIMAType ) ( condElseIf )* ( condElse )? ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:141:5: IF condValueAndUIMAType ( condElseIf )* ( condElse )?
            {
            IF80=(Token)match(input,IF,FOLLOW_IF_in_condIf777);  
            stream_IF.add(IF80);

            pushFollow(FOLLOW_condValueAndUIMAType_in_condIf779);
            condValueAndUIMAType81=condValueAndUIMAType();

            state._fsp--;

            stream_condValueAndUIMAType.add(condValueAndUIMAType81.getTree());
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:141:29: ( condElseIf )*
            loop27:
            do {
                int alt27=2;
                int LA27_0 = input.LA(1);

                if ( (LA27_0==ELSE) ) {
                    int LA27_1 = input.LA(2);

                    if ( (LA27_1==IF) ) {
                        alt27=1;
                    }


                }


                switch (alt27) {
            	case 1 :
            	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:141:29: condElseIf
            	    {
            	    pushFollow(FOLLOW_condElseIf_in_condIf781);
            	    condElseIf82=condElseIf();

            	    state._fsp--;

            	    stream_condElseIf.add(condElseIf82.getTree());

            	    }
            	    break;

            	default :
            	    break loop27;
                }
            } while (true);

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:141:41: ( condElse )?
            int alt28=2;
            int LA28_0 = input.LA(1);

            if ( (LA28_0==ELSE) ) {
                alt28=1;
            }
            switch (alt28) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:141:41: condElse
                    {
                    pushFollow(FOLLOW_condElse_in_condIf784);
                    condElse83=condElse();

                    state._fsp--;

                    stream_condElse.add(condElse83.getTree());

                    }
                    break;

            }



            // AST REWRITE
            // elements: IF, condElseIf, condElse, condValueAndUIMAType
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 142:4: -> ^( COND ^( IF condValueAndUIMAType ) ( condElseIf )* ( condElse )? )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:142:7: ^( COND ^( IF condValueAndUIMAType ) ( condElseIf )* ( condElse )? )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(COND, "COND"), root_1);

                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:142:14: ^( IF condValueAndUIMAType )
                {
                Object root_2 = (Object)adaptor.nil();
                root_2 = (Object)adaptor.becomeRoot(stream_IF.nextNode(), root_2);

                adaptor.addChild(root_2, stream_condValueAndUIMAType.nextTree());

                adaptor.addChild(root_1, root_2);
                }
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:142:41: ( condElseIf )*
                while ( stream_condElseIf.hasNext() ) {
                    adaptor.addChild(root_1, stream_condElseIf.nextTree());

                }
                stream_condElseIf.reset();
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:142:53: ( condElse )?
                if ( stream_condElse.hasNext() ) {
                    adaptor.addChild(root_1, stream_condElse.nextTree());

                }
                stream_condElse.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "condIf"

    public static class condValueAndUIMAType_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "condValueAndUIMAType"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:145:1: condValueAndUIMAType : '(' condBool ')' '{' nodeIfElseValue '}' -> condBool nodeIfElseValue ;
    public final AntlrParser.condValueAndUIMAType_return condValueAndUIMAType() throws RecognitionException {
        AntlrParser.condValueAndUIMAType_return retval = new AntlrParser.condValueAndUIMAType_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal84=null;
        Token char_literal86=null;
        Token char_literal87=null;
        Token char_literal89=null;
        AntlrParser.condBool_return condBool85 = null;

        AntlrParser.nodeIfElseValue_return nodeIfElseValue88 = null;


        Object char_literal84_tree=null;
        Object char_literal86_tree=null;
        Object char_literal87_tree=null;
        Object char_literal89_tree=null;
        RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
        RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68");
        RewriteRuleTokenStream stream_70=new RewriteRuleTokenStream(adaptor,"token 70");
        RewriteRuleTokenStream stream_71=new RewriteRuleTokenStream(adaptor,"token 71");
        RewriteRuleSubtreeStream stream_condBool=new RewriteRuleSubtreeStream(adaptor,"rule condBool");
        RewriteRuleSubtreeStream stream_nodeIfElseValue=new RewriteRuleSubtreeStream(adaptor,"rule nodeIfElseValue");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:146:2: ( '(' condBool ')' '{' nodeIfElseValue '}' -> condBool nodeIfElseValue )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:146:5: '(' condBool ')' '{' nodeIfElseValue '}'
            {
            char_literal84=(Token)match(input,70,FOLLOW_70_in_condValueAndUIMAType819);  
            stream_70.add(char_literal84);

            pushFollow(FOLLOW_condBool_in_condValueAndUIMAType821);
            condBool85=condBool();

            state._fsp--;

            stream_condBool.add(condBool85.getTree());
            char_literal86=(Token)match(input,71,FOLLOW_71_in_condValueAndUIMAType823);  
            stream_71.add(char_literal86);

            char_literal87=(Token)match(input,67,FOLLOW_67_in_condValueAndUIMAType825);  
            stream_67.add(char_literal87);

            pushFollow(FOLLOW_nodeIfElseValue_in_condValueAndUIMAType827);
            nodeIfElseValue88=nodeIfElseValue();

            state._fsp--;

            stream_nodeIfElseValue.add(nodeIfElseValue88.getTree());
            char_literal89=(Token)match(input,68,FOLLOW_68_in_condValueAndUIMAType829);  
            stream_68.add(char_literal89);



            // AST REWRITE
            // elements: nodeIfElseValue, condBool
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 147:4: -> condBool nodeIfElseValue
            {
                adaptor.addChild(root_0, stream_condBool.nextTree());
                adaptor.addChild(root_0, stream_nodeIfElseValue.nextTree());

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "condValueAndUIMAType"

    public static class condBool_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "condBool"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:150:1: condBool : '$' aliasName= word CONDOP (val+= word )+ -> ^( CONDBOOL $aliasName CONDOP ( $val)+ ) ;
    public final AntlrParser.condBool_return condBool() throws RecognitionException {
        AntlrParser.condBool_return retval = new AntlrParser.condBool_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal90=null;
        Token CONDOP91=null;
        List list_val=null;
        AntlrParser.word_return aliasName = null;

        RuleReturnScope val = null;
        Object char_literal90_tree=null;
        Object CONDOP91_tree=null;
        RewriteRuleTokenStream stream_CONDOP=new RewriteRuleTokenStream(adaptor,"token CONDOP");
        RewriteRuleTokenStream stream_75=new RewriteRuleTokenStream(adaptor,"token 75");
        RewriteRuleSubtreeStream stream_word=new RewriteRuleSubtreeStream(adaptor,"rule word");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:151:2: ( '$' aliasName= word CONDOP (val+= word )+ -> ^( CONDBOOL $aliasName CONDOP ( $val)+ ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:151:5: '$' aliasName= word CONDOP (val+= word )+
            {
            char_literal90=(Token)match(input,75,FOLLOW_75_in_condBool851);  
            stream_75.add(char_literal90);

            pushFollow(FOLLOW_word_in_condBool855);
            aliasName=word();

            state._fsp--;

            stream_word.add(aliasName.getTree());
            CONDOP91=(Token)match(input,CONDOP,FOLLOW_CONDOP_in_condBool857);  
            stream_CONDOP.add(CONDOP91);

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:151:31: (val+= word )+
            int cnt29=0;
            loop29:
            do {
                int alt29=2;
                int LA29_0 = input.LA(1);

                if ( (LA29_0==Conf||(LA29_0>=SmallWord && LA29_0<=Number)) ) {
                    alt29=1;
                }


                switch (alt29) {
            	case 1 :
            	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:151:32: val+= word
            	    {
            	    pushFollow(FOLLOW_word_in_condBool862);
            	    val=word();

            	    state._fsp--;

            	    stream_word.add(val.getTree());
            	    if (list_val==null) list_val=new ArrayList();
            	    list_val.add(val.getTree());


            	    }
            	    break;

            	default :
            	    if ( cnt29 >= 1 ) break loop29;
                        EarlyExitException eee =
                            new EarlyExitException(29, input);
                        throw eee;
                }
                cnt29++;
            } while (true);



            // AST REWRITE
            // elements: CONDOP, val, aliasName
            // token labels: 
            // rule labels: aliasName, retval
            // token list labels: 
            // rule list labels: val
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_aliasName=new RewriteRuleSubtreeStream(adaptor,"rule aliasName",aliasName!=null?aliasName.tree:null);
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
            RewriteRuleSubtreeStream stream_val=new RewriteRuleSubtreeStream(adaptor,"token val",list_val);
            root_0 = (Object)adaptor.nil();
            // 152:4: -> ^( CONDBOOL $aliasName CONDOP ( $val)+ )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:152:7: ^( CONDBOOL $aliasName CONDOP ( $val)+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(CONDBOOL, "CONDBOOL"), root_1);

                adaptor.addChild(root_1, stream_aliasName.nextTree());
                adaptor.addChild(root_1, stream_CONDOP.nextNode());
                if ( !(stream_val.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_val.hasNext() ) {
                    adaptor.addChild(root_1, stream_val.nextTree());

                }
                stream_val.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "condBool"

    public static class condElseIf_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "condElseIf"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:155:1: condElseIf : 'else' 'if' condValueAndUIMAType -> ^( ELSEIF condValueAndUIMAType ) ;
    public final AntlrParser.condElseIf_return condElseIf() throws RecognitionException {
        AntlrParser.condElseIf_return retval = new AntlrParser.condElseIf_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token string_literal92=null;
        Token string_literal93=null;
        AntlrParser.condValueAndUIMAType_return condValueAndUIMAType94 = null;


        Object string_literal92_tree=null;
        Object string_literal93_tree=null;
        RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
        RewriteRuleTokenStream stream_ELSE=new RewriteRuleTokenStream(adaptor,"token ELSE");
        RewriteRuleSubtreeStream stream_condValueAndUIMAType=new RewriteRuleSubtreeStream(adaptor,"rule condValueAndUIMAType");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:156:2: ( 'else' 'if' condValueAndUIMAType -> ^( ELSEIF condValueAndUIMAType ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:156:5: 'else' 'if' condValueAndUIMAType
            {
            string_literal92=(Token)match(input,ELSE,FOLLOW_ELSE_in_condElseIf894);  
            stream_ELSE.add(string_literal92);

            string_literal93=(Token)match(input,IF,FOLLOW_IF_in_condElseIf896);  
            stream_IF.add(string_literal93);

            pushFollow(FOLLOW_condValueAndUIMAType_in_condElseIf898);
            condValueAndUIMAType94=condValueAndUIMAType();

            state._fsp--;

            stream_condValueAndUIMAType.add(condValueAndUIMAType94.getTree());


            // AST REWRITE
            // elements: condValueAndUIMAType
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 156:38: -> ^( ELSEIF condValueAndUIMAType )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:156:41: ^( ELSEIF condValueAndUIMAType )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ELSEIF, "ELSEIF"), root_1);

                adaptor.addChild(root_1, stream_condValueAndUIMAType.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "condElseIf"

    public static class condElse_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "condElse"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:159:1: condElse : 'else' '{' nodeIfElseValue '}' -> ^( ELSE nodeIfElseValue ) ;
    public final AntlrParser.condElse_return condElse() throws RecognitionException {
        AntlrParser.condElse_return retval = new AntlrParser.condElse_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token string_literal95=null;
        Token char_literal96=null;
        Token char_literal98=null;
        AntlrParser.nodeIfElseValue_return nodeIfElseValue97 = null;


        Object string_literal95_tree=null;
        Object char_literal96_tree=null;
        Object char_literal98_tree=null;
        RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
        RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68");
        RewriteRuleTokenStream stream_ELSE=new RewriteRuleTokenStream(adaptor,"token ELSE");
        RewriteRuleSubtreeStream stream_nodeIfElseValue=new RewriteRuleSubtreeStream(adaptor,"rule nodeIfElseValue");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:160:2: ( 'else' '{' nodeIfElseValue '}' -> ^( ELSE nodeIfElseValue ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:160:5: 'else' '{' nodeIfElseValue '}'
            {
            string_literal95=(Token)match(input,ELSE,FOLLOW_ELSE_in_condElse918);  
            stream_ELSE.add(string_literal95);

            char_literal96=(Token)match(input,67,FOLLOW_67_in_condElse920);  
            stream_67.add(char_literal96);

            pushFollow(FOLLOW_nodeIfElseValue_in_condElse922);
            nodeIfElseValue97=nodeIfElseValue();

            state._fsp--;

            stream_nodeIfElseValue.add(nodeIfElseValue97.getTree());
            char_literal98=(Token)match(input,68,FOLLOW_68_in_condElse924);  
            stream_68.add(char_literal98);



            // AST REWRITE
            // elements: nodeIfElseValue
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 160:36: -> ^( ELSE nodeIfElseValue )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:160:39: ^( ELSE nodeIfElseValue )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ELSE, "ELSE"), root_1);

                adaptor.addChild(root_1, stream_nodeIfElseValue.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "condElse"

    public static class graph_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "graph"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:164:1: graph : GRAPH '=' '{' ( singleTriple )+ '}' -> ^( GRAPH ( singleTriple )+ ) ;
    public final AntlrParser.graph_return graph() throws RecognitionException {
        AntlrParser.graph_return retval = new AntlrParser.graph_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token GRAPH99=null;
        Token char_literal100=null;
        Token char_literal101=null;
        Token char_literal103=null;
        AntlrParser.singleTriple_return singleTriple102 = null;


        Object GRAPH99_tree=null;
        Object char_literal100_tree=null;
        Object char_literal101_tree=null;
        Object char_literal103_tree=null;
        RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
        RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68");
        RewriteRuleTokenStream stream_64=new RewriteRuleTokenStream(adaptor,"token 64");
        RewriteRuleTokenStream stream_GRAPH=new RewriteRuleTokenStream(adaptor,"token GRAPH");
        RewriteRuleSubtreeStream stream_singleTriple=new RewriteRuleSubtreeStream(adaptor,"rule singleTriple");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:165:2: ( GRAPH '=' '{' ( singleTriple )+ '}' -> ^( GRAPH ( singleTriple )+ ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:165:5: GRAPH '=' '{' ( singleTriple )+ '}'
            {
            GRAPH99=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graph945);  
            stream_GRAPH.add(GRAPH99);

            char_literal100=(Token)match(input,64,FOLLOW_64_in_graph947);  
            stream_64.add(char_literal100);

            char_literal101=(Token)match(input,67,FOLLOW_67_in_graph949);  
            stream_67.add(char_literal101);

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:165:19: ( singleTriple )+
            int cnt30=0;
            loop30:
            do {
                int alt30=2;
                int LA30_0 = input.LA(1);

                if ( (LA30_0==OPTIONAL||LA30_0==SmallWord||LA30_0==Number||LA30_0==75||LA30_0==77||LA30_0==86||LA30_0==88) ) {
                    alt30=1;
                }


                switch (alt30) {
            	case 1 :
            	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:165:19: singleTriple
            	    {
            	    pushFollow(FOLLOW_singleTriple_in_graph951);
            	    singleTriple102=singleTriple();

            	    state._fsp--;

            	    stream_singleTriple.add(singleTriple102.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt30 >= 1 ) break loop30;
                        EarlyExitException eee =
                            new EarlyExitException(30, input);
                        throw eee;
                }
                cnt30++;
            } while (true);

            char_literal103=(Token)match(input,68,FOLLOW_68_in_graph954);  
            stream_68.add(char_literal103);



            // AST REWRITE
            // elements: singleTriple, GRAPH
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 165:37: -> ^( GRAPH ( singleTriple )+ )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:165:40: ^( GRAPH ( singleTriple )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_GRAPH.nextNode(), root_1);

                if ( !(stream_singleTriple.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_singleTriple.hasNext() ) {
                    adaptor.addChild(root_1, stream_singleTriple.nextTree());

                }
                stream_singleTriple.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "graph"

    public static class singleTriple_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "singleTriple"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:168:1: singleTriple : ( tripleSubj triplePred tripleObj '.' -> ^( TRIPLE ^( SUBJ tripleSubj ) ^( PRED triplePred ) ^( OBJ tripleObj ) ) | OPTIONAL '{' tripleSubj triplePred tripleObj ( '.' )? '}' ( '.' )? -> ^( OPTIONALTRIPLE ^( SUBJ tripleSubj ) ^( PRED triplePred ) ^( OBJ tripleObj ) ) );
    public final AntlrParser.singleTriple_return singleTriple() throws RecognitionException {
        AntlrParser.singleTriple_return retval = new AntlrParser.singleTriple_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal107=null;
        Token OPTIONAL108=null;
        Token char_literal109=null;
        Token char_literal113=null;
        Token char_literal114=null;
        Token char_literal115=null;
        AntlrParser.tripleSubj_return tripleSubj104 = null;

        AntlrParser.triplePred_return triplePred105 = null;

        AntlrParser.tripleObj_return tripleObj106 = null;

        AntlrParser.tripleSubj_return tripleSubj110 = null;

        AntlrParser.triplePred_return triplePred111 = null;

        AntlrParser.tripleObj_return tripleObj112 = null;


        Object char_literal107_tree=null;
        Object OPTIONAL108_tree=null;
        Object char_literal109_tree=null;
        Object char_literal113_tree=null;
        Object char_literal114_tree=null;
        Object char_literal115_tree=null;
        RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
        RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68");
        RewriteRuleTokenStream stream_OPTIONAL=new RewriteRuleTokenStream(adaptor,"token OPTIONAL");
        RewriteRuleTokenStream stream_76=new RewriteRuleTokenStream(adaptor,"token 76");
        RewriteRuleSubtreeStream stream_tripleObj=new RewriteRuleSubtreeStream(adaptor,"rule tripleObj");
        RewriteRuleSubtreeStream stream_tripleSubj=new RewriteRuleSubtreeStream(adaptor,"rule tripleSubj");
        RewriteRuleSubtreeStream stream_triplePred=new RewriteRuleSubtreeStream(adaptor,"rule triplePred");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:169:2: ( tripleSubj triplePred tripleObj '.' -> ^( TRIPLE ^( SUBJ tripleSubj ) ^( PRED triplePred ) ^( OBJ tripleObj ) ) | OPTIONAL '{' tripleSubj triplePred tripleObj ( '.' )? '}' ( '.' )? -> ^( OPTIONALTRIPLE ^( SUBJ tripleSubj ) ^( PRED triplePred ) ^( OBJ tripleObj ) ) )
            int alt33=2;
            int LA33_0 = input.LA(1);

            if ( (LA33_0==SmallWord||LA33_0==Number||LA33_0==75||LA33_0==77||LA33_0==86||LA33_0==88) ) {
                alt33=1;
            }
            else if ( (LA33_0==OPTIONAL) ) {
                alt33=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 33, 0, input);

                throw nvae;
            }
            switch (alt33) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:169:5: tripleSubj triplePred tripleObj '.'
                    {
                    pushFollow(FOLLOW_tripleSubj_in_singleTriple975);
                    tripleSubj104=tripleSubj();

                    state._fsp--;

                    stream_tripleSubj.add(tripleSubj104.getTree());
                    pushFollow(FOLLOW_triplePred_in_singleTriple978);
                    triplePred105=triplePred();

                    state._fsp--;

                    stream_triplePred.add(triplePred105.getTree());
                    pushFollow(FOLLOW_tripleObj_in_singleTriple981);
                    tripleObj106=tripleObj();

                    state._fsp--;

                    stream_tripleObj.add(tripleObj106.getTree());
                    char_literal107=(Token)match(input,76,FOLLOW_76_in_singleTriple983);  
                    stream_76.add(char_literal107);



                    // AST REWRITE
                    // elements: triplePred, tripleObj, tripleSubj
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 170:4: -> ^( TRIPLE ^( SUBJ tripleSubj ) ^( PRED triplePred ) ^( OBJ tripleObj ) )
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:170:7: ^( TRIPLE ^( SUBJ tripleSubj ) ^( PRED triplePred ) ^( OBJ tripleObj ) )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TRIPLE, "TRIPLE"), root_1);

                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:170:16: ^( SUBJ tripleSubj )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(SUBJ, "SUBJ"), root_2);

                        adaptor.addChild(root_2, stream_tripleSubj.nextTree());

                        adaptor.addChild(root_1, root_2);
                        }
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:170:35: ^( PRED triplePred )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(PRED, "PRED"), root_2);

                        adaptor.addChild(root_2, stream_triplePred.nextTree());

                        adaptor.addChild(root_1, root_2);
                        }
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:170:54: ^( OBJ tripleObj )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(OBJ, "OBJ"), root_2);

                        adaptor.addChild(root_2, stream_tripleObj.nextTree());

                        adaptor.addChild(root_1, root_2);
                        }

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:171:5: OPTIONAL '{' tripleSubj triplePred tripleObj ( '.' )? '}' ( '.' )?
                    {
                    OPTIONAL108=(Token)match(input,OPTIONAL,FOLLOW_OPTIONAL_in_singleTriple1017);  
                    stream_OPTIONAL.add(OPTIONAL108);

                    char_literal109=(Token)match(input,67,FOLLOW_67_in_singleTriple1019);  
                    stream_67.add(char_literal109);

                    pushFollow(FOLLOW_tripleSubj_in_singleTriple1021);
                    tripleSubj110=tripleSubj();

                    state._fsp--;

                    stream_tripleSubj.add(tripleSubj110.getTree());
                    pushFollow(FOLLOW_triplePred_in_singleTriple1024);
                    triplePred111=triplePred();

                    state._fsp--;

                    stream_triplePred.add(triplePred111.getTree());
                    pushFollow(FOLLOW_tripleObj_in_singleTriple1027);
                    tripleObj112=tripleObj();

                    state._fsp--;

                    stream_tripleObj.add(tripleObj112.getTree());
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:171:52: ( '.' )?
                    int alt31=2;
                    int LA31_0 = input.LA(1);

                    if ( (LA31_0==76) ) {
                        alt31=1;
                    }
                    switch (alt31) {
                        case 1 :
                            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:171:52: '.'
                            {
                            char_literal113=(Token)match(input,76,FOLLOW_76_in_singleTriple1029);  
                            stream_76.add(char_literal113);


                            }
                            break;

                    }

                    char_literal114=(Token)match(input,68,FOLLOW_68_in_singleTriple1032);  
                    stream_68.add(char_literal114);

                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:171:60: ( '.' )?
                    int alt32=2;
                    int LA32_0 = input.LA(1);

                    if ( (LA32_0==76) ) {
                        alt32=1;
                    }
                    switch (alt32) {
                        case 1 :
                            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:171:60: '.'
                            {
                            char_literal115=(Token)match(input,76,FOLLOW_76_in_singleTriple1033);  
                            stream_76.add(char_literal115);


                            }
                            break;

                    }



                    // AST REWRITE
                    // elements: tripleObj, triplePred, tripleSubj
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 172:4: -> ^( OPTIONALTRIPLE ^( SUBJ tripleSubj ) ^( PRED triplePred ) ^( OBJ tripleObj ) )
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:172:7: ^( OPTIONALTRIPLE ^( SUBJ tripleSubj ) ^( PRED triplePred ) ^( OBJ tripleObj ) )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(OPTIONALTRIPLE, "OPTIONALTRIPLE"), root_1);

                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:172:24: ^( SUBJ tripleSubj )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(SUBJ, "SUBJ"), root_2);

                        adaptor.addChild(root_2, stream_tripleSubj.nextTree());

                        adaptor.addChild(root_1, root_2);
                        }
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:172:43: ^( PRED triplePred )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(PRED, "PRED"), root_2);

                        adaptor.addChild(root_2, stream_triplePred.nextTree());

                        adaptor.addChild(root_1, root_2);
                        }
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:172:62: ^( OBJ tripleObj )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(OBJ, "OBJ"), root_2);

                        adaptor.addChild(root_2, stream_tripleObj.nextTree());

                        adaptor.addChild(root_1, root_2);
                        }

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "singleTriple"

    public static class tripleSubj_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "tripleSubj"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:175:1: tripleSubj : ( tripleElem | ontClass | ontProperty | valueDatatype );
    public final AntlrParser.tripleSubj_return tripleSubj() throws RecognitionException {
        AntlrParser.tripleSubj_return retval = new AntlrParser.tripleSubj_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AntlrParser.tripleElem_return tripleElem116 = null;

        AntlrParser.ontClass_return ontClass117 = null;

        AntlrParser.ontProperty_return ontProperty118 = null;

        AntlrParser.valueDatatype_return valueDatatype119 = null;



        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:176:2: ( tripleElem | ontClass | ontProperty | valueDatatype )
            int alt34=4;
            alt34 = dfa34.predict(input);
            switch (alt34) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:176:5: tripleElem
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_tripleElem_in_tripleSubj1074);
                    tripleElem116=tripleElem();

                    state._fsp--;

                    adaptor.addChild(root_0, tripleElem116.getTree());

                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:176:16: ontClass
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_ontClass_in_tripleSubj1076);
                    ontClass117=ontClass();

                    state._fsp--;

                    adaptor.addChild(root_0, ontClass117.getTree());

                    }
                    break;
                case 3 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:176:25: ontProperty
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_ontProperty_in_tripleSubj1078);
                    ontProperty118=ontProperty();

                    state._fsp--;

                    adaptor.addChild(root_0, ontProperty118.getTree());

                    }
                    break;
                case 4 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:176:37: valueDatatype
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_valueDatatype_in_tripleSubj1080);
                    valueDatatype119=valueDatatype();

                    state._fsp--;

                    adaptor.addChild(root_0, valueDatatype119.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "tripleSubj"

    public static class triplePred_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "triplePred"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:179:1: triplePred : ( tripleElem | ontProperty | ABBR );
    public final AntlrParser.triplePred_return triplePred() throws RecognitionException {
        AntlrParser.triplePred_return retval = new AntlrParser.triplePred_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token ABBR122=null;
        AntlrParser.tripleElem_return tripleElem120 = null;

        AntlrParser.ontProperty_return ontProperty121 = null;


        Object ABBR122_tree=null;

        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:180:2: ( tripleElem | ontProperty | ABBR )
            int alt35=3;
            switch ( input.LA(1) ) {
            case 75:
            case 77:
                {
                alt35=1;
                }
                break;
            case SmallWord:
            case 86:
                {
                alt35=2;
                }
                break;
            case ABBR:
                {
                alt35=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 35, 0, input);

                throw nvae;
            }

            switch (alt35) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:180:5: tripleElem
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_tripleElem_in_triplePred1093);
                    tripleElem120=tripleElem();

                    state._fsp--;

                    adaptor.addChild(root_0, tripleElem120.getTree());

                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:180:16: ontProperty
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_ontProperty_in_triplePred1095);
                    ontProperty121=ontProperty();

                    state._fsp--;

                    adaptor.addChild(root_0, ontProperty121.getTree());

                    }
                    break;
                case 3 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:180:28: ABBR
                    {
                    root_0 = (Object)adaptor.nil();

                    ABBR122=(Token)match(input,ABBR,FOLLOW_ABBR_in_triplePred1097); 
                    ABBR122_tree = (Object)adaptor.create(ABBR122);
                    adaptor.addChild(root_0, ABBR122_tree);


                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "triplePred"

    public static class tripleObj_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "tripleObj"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:183:1: tripleObj : ( tripleElem | ontClass | ontProperty | valueDatatype );
    public final AntlrParser.tripleObj_return tripleObj() throws RecognitionException {
        AntlrParser.tripleObj_return retval = new AntlrParser.tripleObj_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AntlrParser.tripleElem_return tripleElem123 = null;

        AntlrParser.ontClass_return ontClass124 = null;

        AntlrParser.ontProperty_return ontProperty125 = null;

        AntlrParser.valueDatatype_return valueDatatype126 = null;



        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:184:2: ( tripleElem | ontClass | ontProperty | valueDatatype )
            int alt36=4;
            alt36 = dfa36.predict(input);
            switch (alt36) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:184:5: tripleElem
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_tripleElem_in_tripleObj1110);
                    tripleElem123=tripleElem();

                    state._fsp--;

                    adaptor.addChild(root_0, tripleElem123.getTree());

                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:184:16: ontClass
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_ontClass_in_tripleObj1112);
                    ontClass124=ontClass();

                    state._fsp--;

                    adaptor.addChild(root_0, ontClass124.getTree());

                    }
                    break;
                case 3 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:184:25: ontProperty
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_ontProperty_in_tripleObj1114);
                    ontProperty125=ontProperty();

                    state._fsp--;

                    adaptor.addChild(root_0, ontProperty125.getTree());

                    }
                    break;
                case 4 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:184:37: valueDatatype
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_valueDatatype_in_tripleObj1116);
                    valueDatatype126=valueDatatype();

                    state._fsp--;

                    adaptor.addChild(root_0, valueDatatype126.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "tripleObj"

    public static class tripleElem_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "tripleElem"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:187:1: tripleElem : ( refId | var ) ;
    public final AntlrParser.tripleElem_return tripleElem() throws RecognitionException {
        AntlrParser.tripleElem_return retval = new AntlrParser.tripleElem_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AntlrParser.refId_return refId127 = null;

        AntlrParser.var_return var128 = null;



        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:188:2: ( ( refId | var ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:188:5: ( refId | var )
            {
            root_0 = (Object)adaptor.nil();

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:188:5: ( refId | var )
            int alt37=2;
            int LA37_0 = input.LA(1);

            if ( (LA37_0==75) ) {
                alt37=1;
            }
            else if ( (LA37_0==77) ) {
                alt37=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 37, 0, input);

                throw nvae;
            }
            switch (alt37) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:188:6: refId
                    {
                    pushFollow(FOLLOW_refId_in_tripleElem1132);
                    refId127=refId();

                    state._fsp--;

                    adaptor.addChild(root_0, refId127.getTree());

                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:188:12: var
                    {
                    pushFollow(FOLLOW_var_in_tripleElem1134);
                    var128=var();

                    state._fsp--;

                    adaptor.addChild(root_0, var128.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "tripleElem"

    public static class refId_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "refId"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:191:1: refId : ( '$' word -> ^( PLACEHOLDER word ) | '$' idPR= word ':' nodeId= word -> ^( PLACEHOLDER $idPR $nodeId) );
    public final AntlrParser.refId_return refId() throws RecognitionException {
        AntlrParser.refId_return retval = new AntlrParser.refId_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal129=null;
        Token char_literal131=null;
        Token char_literal132=null;
        AntlrParser.word_return idPR = null;

        AntlrParser.word_return nodeId = null;

        AntlrParser.word_return word130 = null;


        Object char_literal129_tree=null;
        Object char_literal131_tree=null;
        Object char_literal132_tree=null;
        RewriteRuleTokenStream stream_66=new RewriteRuleTokenStream(adaptor,"token 66");
        RewriteRuleTokenStream stream_75=new RewriteRuleTokenStream(adaptor,"token 75");
        RewriteRuleSubtreeStream stream_word=new RewriteRuleSubtreeStream(adaptor,"rule word");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:192:2: ( '$' word -> ^( PLACEHOLDER word ) | '$' idPR= word ':' nodeId= word -> ^( PLACEHOLDER $idPR $nodeId) )
            int alt38=2;
            alt38 = dfa38.predict(input);
            switch (alt38) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:192:5: '$' word
                    {
                    char_literal129=(Token)match(input,75,FOLLOW_75_in_refId1153);  
                    stream_75.add(char_literal129);

                    pushFollow(FOLLOW_word_in_refId1155);
                    word130=word();

                    state._fsp--;

                    stream_word.add(word130.getTree());


                    // AST REWRITE
                    // elements: word
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 192:14: -> ^( PLACEHOLDER word )
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:192:17: ^( PLACEHOLDER word )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PLACEHOLDER, "PLACEHOLDER"), root_1);

                        adaptor.addChild(root_1, stream_word.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:193:5: '$' idPR= word ':' nodeId= word
                    {
                    char_literal131=(Token)match(input,75,FOLLOW_75_in_refId1169);  
                    stream_75.add(char_literal131);

                    pushFollow(FOLLOW_word_in_refId1173);
                    idPR=word();

                    state._fsp--;

                    stream_word.add(idPR.getTree());
                    char_literal132=(Token)match(input,66,FOLLOW_66_in_refId1175);  
                    stream_66.add(char_literal132);

                    pushFollow(FOLLOW_word_in_refId1179);
                    nodeId=word();

                    state._fsp--;

                    stream_word.add(nodeId.getTree());


                    // AST REWRITE
                    // elements: idPR, nodeId
                    // token labels: 
                    // rule labels: retval, nodeId, idPR
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
                    RewriteRuleSubtreeStream stream_nodeId=new RewriteRuleSubtreeStream(adaptor,"rule nodeId",nodeId!=null?nodeId.tree:null);
                    RewriteRuleSubtreeStream stream_idPR=new RewriteRuleSubtreeStream(adaptor,"rule idPR",idPR!=null?idPR.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 193:35: -> ^( PLACEHOLDER $idPR $nodeId)
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:193:38: ^( PLACEHOLDER $idPR $nodeId)
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PLACEHOLDER, "PLACEHOLDER"), root_1);

                        adaptor.addChild(root_1, stream_idPR.nextTree());
                        adaptor.addChild(root_1, stream_nodeId.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "refId"

    public static class var_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "var"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:196:1: var : '?' word -> ^( VAR word ) ;
    public final AntlrParser.var_return var() throws RecognitionException {
        AntlrParser.var_return retval = new AntlrParser.var_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal133=null;
        AntlrParser.word_return word134 = null;


        Object char_literal133_tree=null;
        RewriteRuleTokenStream stream_77=new RewriteRuleTokenStream(adaptor,"token 77");
        RewriteRuleSubtreeStream stream_word=new RewriteRuleSubtreeStream(adaptor,"rule word");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:197:2: ( '?' word -> ^( VAR word ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:197:5: '?' word
            {
            char_literal133=(Token)match(input,77,FOLLOW_77_in_var1204);  
            stream_77.add(char_literal133);

            pushFollow(FOLLOW_word_in_var1206);
            word134=word();

            state._fsp--;

            stream_word.add(word134.getTree());


            // AST REWRITE
            // elements: word
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 197:14: -> ^( VAR word )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:197:17: ^( VAR word )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(VAR, "VAR"), root_1);

                adaptor.addChild(root_1, stream_word.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "var"

    public static class where_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "where"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:201:1: where : WHERE '=' '{' ( singleTriple )+ '}' -> ^( WHERE ( singleTriple )+ ) ;
    public final AntlrParser.where_return where() throws RecognitionException {
        AntlrParser.where_return retval = new AntlrParser.where_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token WHERE135=null;
        Token char_literal136=null;
        Token char_literal137=null;
        Token char_literal139=null;
        AntlrParser.singleTriple_return singleTriple138 = null;


        Object WHERE135_tree=null;
        Object char_literal136_tree=null;
        Object char_literal137_tree=null;
        Object char_literal139_tree=null;
        RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
        RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
        RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68");
        RewriteRuleTokenStream stream_64=new RewriteRuleTokenStream(adaptor,"token 64");
        RewriteRuleSubtreeStream stream_singleTriple=new RewriteRuleSubtreeStream(adaptor,"rule singleTriple");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:202:2: ( WHERE '=' '{' ( singleTriple )+ '}' -> ^( WHERE ( singleTriple )+ ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:202:5: WHERE '=' '{' ( singleTriple )+ '}'
            {
            WHERE135=(Token)match(input,WHERE,FOLLOW_WHERE_in_where1227);  
            stream_WHERE.add(WHERE135);

            char_literal136=(Token)match(input,64,FOLLOW_64_in_where1229);  
            stream_64.add(char_literal136);

            char_literal137=(Token)match(input,67,FOLLOW_67_in_where1231);  
            stream_67.add(char_literal137);

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:202:19: ( singleTriple )+
            int cnt39=0;
            loop39:
            do {
                int alt39=2;
                int LA39_0 = input.LA(1);

                if ( (LA39_0==OPTIONAL||LA39_0==SmallWord||LA39_0==Number||LA39_0==75||LA39_0==77||LA39_0==86||LA39_0==88) ) {
                    alt39=1;
                }


                switch (alt39) {
            	case 1 :
            	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:202:19: singleTriple
            	    {
            	    pushFollow(FOLLOW_singleTriple_in_where1233);
            	    singleTriple138=singleTriple();

            	    state._fsp--;

            	    stream_singleTriple.add(singleTriple138.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt39 >= 1 ) break loop39;
                        EarlyExitException eee =
                            new EarlyExitException(39, input);
                        throw eee;
                }
                cnt39++;
            } while (true);

            char_literal139=(Token)match(input,68,FOLLOW_68_in_where1236);  
            stream_68.add(char_literal139);



            // AST REWRITE
            // elements: WHERE, singleTriple
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 202:37: -> ^( WHERE ( singleTriple )+ )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:202:40: ^( WHERE ( singleTriple )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_WHERE.nextNode(), root_1);

                if ( !(stream_singleTriple.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_singleTriple.hasNext() ) {
                    adaptor.addChild(root_1, stream_singleTriple.nextTree());

                }
                stream_singleTriple.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "where"

    public static class parameters_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "parameters"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:206:1: parameters : PARAMETERS '=' '{' ( parameterNameValue ( ',' parameterNameValue )* )? '}' -> ^( PARAMETERSLIST ( parameterNameValue )+ ) ;
    public final AntlrParser.parameters_return parameters() throws RecognitionException {
        AntlrParser.parameters_return retval = new AntlrParser.parameters_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token PARAMETERS140=null;
        Token char_literal141=null;
        Token char_literal142=null;
        Token char_literal144=null;
        Token char_literal146=null;
        AntlrParser.parameterNameValue_return parameterNameValue143 = null;

        AntlrParser.parameterNameValue_return parameterNameValue145 = null;


        Object PARAMETERS140_tree=null;
        Object char_literal141_tree=null;
        Object char_literal142_tree=null;
        Object char_literal144_tree=null;
        Object char_literal146_tree=null;
        RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67");
        RewriteRuleTokenStream stream_69=new RewriteRuleTokenStream(adaptor,"token 69");
        RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68");
        RewriteRuleTokenStream stream_PARAMETERS=new RewriteRuleTokenStream(adaptor,"token PARAMETERS");
        RewriteRuleTokenStream stream_64=new RewriteRuleTokenStream(adaptor,"token 64");
        RewriteRuleSubtreeStream stream_parameterNameValue=new RewriteRuleSubtreeStream(adaptor,"rule parameterNameValue");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:207:2: ( PARAMETERS '=' '{' ( parameterNameValue ( ',' parameterNameValue )* )? '}' -> ^( PARAMETERSLIST ( parameterNameValue )+ ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:207:5: PARAMETERS '=' '{' ( parameterNameValue ( ',' parameterNameValue )* )? '}'
            {
            PARAMETERS140=(Token)match(input,PARAMETERS,FOLLOW_PARAMETERS_in_parameters1258);  
            stream_PARAMETERS.add(PARAMETERS140);

            char_literal141=(Token)match(input,64,FOLLOW_64_in_parameters1260);  
            stream_64.add(char_literal141);

            char_literal142=(Token)match(input,67,FOLLOW_67_in_parameters1262);  
            stream_67.add(char_literal142);

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:207:24: ( parameterNameValue ( ',' parameterNameValue )* )?
            int alt41=2;
            int LA41_0 = input.LA(1);

            if ( (LA41_0==SmallWord) ) {
                alt41=1;
            }
            switch (alt41) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:207:25: parameterNameValue ( ',' parameterNameValue )*
                    {
                    pushFollow(FOLLOW_parameterNameValue_in_parameters1265);
                    parameterNameValue143=parameterNameValue();

                    state._fsp--;

                    stream_parameterNameValue.add(parameterNameValue143.getTree());
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:207:44: ( ',' parameterNameValue )*
                    loop40:
                    do {
                        int alt40=2;
                        int LA40_0 = input.LA(1);

                        if ( (LA40_0==69) ) {
                            alt40=1;
                        }


                        switch (alt40) {
                    	case 1 :
                    	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:207:45: ',' parameterNameValue
                    	    {
                    	    char_literal144=(Token)match(input,69,FOLLOW_69_in_parameters1268);  
                    	    stream_69.add(char_literal144);

                    	    pushFollow(FOLLOW_parameterNameValue_in_parameters1270);
                    	    parameterNameValue145=parameterNameValue();

                    	    state._fsp--;

                    	    stream_parameterNameValue.add(parameterNameValue145.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop40;
                        }
                    } while (true);


                    }
                    break;

            }

            char_literal146=(Token)match(input,68,FOLLOW_68_in_parameters1278);  
            stream_68.add(char_literal146);



            // AST REWRITE
            // elements: parameterNameValue
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 207:78: -> ^( PARAMETERSLIST ( parameterNameValue )+ )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:207:81: ^( PARAMETERSLIST ( parameterNameValue )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PARAMETERSLIST, "PARAMETERSLIST"), root_1);

                if ( !(stream_parameterNameValue.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_parameterNameValue.hasNext() ) {
                    adaptor.addChild(root_1, stream_parameterNameValue.nextTree());

                }
                stream_parameterNameValue.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "parameters"

    public static class parameterNameValue_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "parameterNameValue"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:210:1: parameterNameValue : name= parameterName ( '=' val= parameterValue )? -> ^( PARAMETER ^( PARAMETERNAME $name) ( ^( PARAMETERVALUE $val) )? ) ;
    public final AntlrParser.parameterNameValue_return parameterNameValue() throws RecognitionException {
        AntlrParser.parameterNameValue_return retval = new AntlrParser.parameterNameValue_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal147=null;
        AntlrParser.parameterName_return name = null;

        AntlrParser.parameterValue_return val = null;


        Object char_literal147_tree=null;
        RewriteRuleTokenStream stream_64=new RewriteRuleTokenStream(adaptor,"token 64");
        RewriteRuleSubtreeStream stream_parameterValue=new RewriteRuleSubtreeStream(adaptor,"rule parameterValue");
        RewriteRuleSubtreeStream stream_parameterName=new RewriteRuleSubtreeStream(adaptor,"rule parameterName");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:211:2: (name= parameterName ( '=' val= parameterValue )? -> ^( PARAMETER ^( PARAMETERNAME $name) ( ^( PARAMETERVALUE $val) )? ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:211:5: name= parameterName ( '=' val= parameterValue )?
            {
            pushFollow(FOLLOW_parameterName_in_parameterNameValue1302);
            name=parameterName();

            state._fsp--;

            stream_parameterName.add(name.getTree());
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:211:24: ( '=' val= parameterValue )?
            int alt42=2;
            int LA42_0 = input.LA(1);

            if ( (LA42_0==64) ) {
                alt42=1;
            }
            switch (alt42) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:211:25: '=' val= parameterValue
                    {
                    char_literal147=(Token)match(input,64,FOLLOW_64_in_parameterNameValue1305);  
                    stream_64.add(char_literal147);

                    pushFollow(FOLLOW_parameterValue_in_parameterNameValue1309);
                    val=parameterValue();

                    state._fsp--;

                    stream_parameterValue.add(val.getTree());

                    }
                    break;

            }



            // AST REWRITE
            // elements: name, val
            // token labels: 
            // rule labels: val, retval, name
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_val=new RewriteRuleSubtreeStream(adaptor,"rule val",val!=null?val.tree:null);
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
            RewriteRuleSubtreeStream stream_name=new RewriteRuleSubtreeStream(adaptor,"rule name",name!=null?name.tree:null);

            root_0 = (Object)adaptor.nil();
            // 211:50: -> ^( PARAMETER ^( PARAMETERNAME $name) ( ^( PARAMETERVALUE $val) )? )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:211:53: ^( PARAMETER ^( PARAMETERNAME $name) ( ^( PARAMETERVALUE $val) )? )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PARAMETER, "PARAMETER"), root_1);

                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:211:65: ^( PARAMETERNAME $name)
                {
                Object root_2 = (Object)adaptor.nil();
                root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(PARAMETERNAME, "PARAMETERNAME"), root_2);

                adaptor.addChild(root_2, stream_name.nextTree());

                adaptor.addChild(root_1, root_2);
                }
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:211:88: ( ^( PARAMETERVALUE $val) )?
                if ( stream_val.hasNext() ) {
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:211:88: ^( PARAMETERVALUE $val)
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(PARAMETERVALUE, "PARAMETERVALUE"), root_2);

                    adaptor.addChild(root_2, stream_val.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_val.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "parameterNameValue"

    public static class namespace_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "namespace"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:214:1: namespace : ( 'http' | 'ftp' ) '://' word ( ( '/' | '.' ) word )* ( '#' | '/' ) ;
    public final AntlrParser.namespace_return namespace() throws RecognitionException {
        AntlrParser.namespace_return retval = new AntlrParser.namespace_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token set148=null;
        Token string_literal149=null;
        Token set151=null;
        Token set153=null;
        AntlrParser.word_return word150 = null;

        AntlrParser.word_return word152 = null;


        Object set148_tree=null;
        Object string_literal149_tree=null;
        Object set151_tree=null;
        Object set153_tree=null;

        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:214:10: ( ( 'http' | 'ftp' ) '://' word ( ( '/' | '.' ) word )* ( '#' | '/' ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:214:12: ( 'http' | 'ftp' ) '://' word ( ( '/' | '.' ) word )* ( '#' | '/' )
            {
            root_0 = (Object)adaptor.nil();

            set148=(Token)input.LT(1);
            if ( (input.LA(1)>=78 && input.LA(1)<=79) ) {
                input.consume();
                adaptor.addChild(root_0, (Object)adaptor.create(set148));
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }

            string_literal149=(Token)match(input,80,FOLLOW_80_in_namespace1346); 
            string_literal149_tree = (Object)adaptor.create(string_literal149);
            adaptor.addChild(root_0, string_literal149_tree);

            pushFollow(FOLLOW_word_in_namespace1348);
            word150=word();

            state._fsp--;

            adaptor.addChild(root_0, word150.getTree());
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:214:36: ( ( '/' | '.' ) word )*
            loop43:
            do {
                int alt43=2;
                int LA43_0 = input.LA(1);

                if ( (LA43_0==81) ) {
                    switch ( input.LA(2) ) {
                    case SmallWord:
                        {
                        int LA43_4 = input.LA(3);

                        if ( (LA43_4==76||(LA43_4>=81 && LA43_4<=82)) ) {
                            alt43=1;
                        }


                        }
                        break;
                    case CapitalWord:
                        {
                        int LA43_5 = input.LA(3);

                        if ( (LA43_5==76||(LA43_5>=81 && LA43_5<=82)) ) {
                            alt43=1;
                        }


                        }
                        break;
                    case Conf:
                    case Number:
                        {
                        alt43=1;
                        }
                        break;

                    }

                }
                else if ( (LA43_0==76) ) {
                    alt43=1;
                }


                switch (alt43) {
            	case 1 :
            	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:214:37: ( '/' | '.' ) word
            	    {
            	    set151=(Token)input.LT(1);
            	    if ( input.LA(1)==76||input.LA(1)==81 ) {
            	        input.consume();
            	        adaptor.addChild(root_0, (Object)adaptor.create(set151));
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }

            	    pushFollow(FOLLOW_word_in_namespace1355);
            	    word152=word();

            	    state._fsp--;

            	    adaptor.addChild(root_0, word152.getTree());

            	    }
            	    break;

            	default :
            	    break loop43;
                }
            } while (true);

            set153=(Token)input.LT(1);
            if ( (input.LA(1)>=81 && input.LA(1)<=82) ) {
                input.consume();
                adaptor.addChild(root_0, (Object)adaptor.create(set153));
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "namespace"

    public static class prefix_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "prefix"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:215:1: prefix : SmallWord ;
    public final AntlrParser.prefix_return prefix() throws RecognitionException {
        AntlrParser.prefix_return retval = new AntlrParser.prefix_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token SmallWord154=null;

        Object SmallWord154_tree=null;

        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:215:7: ( SmallWord )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:215:9: SmallWord
            {
            root_0 = (Object)adaptor.nil();

            SmallWord154=(Token)match(input,SmallWord,FOLLOW_SmallWord_in_prefix1370); 
            SmallWord154_tree = (Object)adaptor.create(SmallWord154);
            adaptor.addChild(root_0, SmallWord154_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "prefix"

    public static class uimaType_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "uimaType"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:216:1: uimaType : SmallWord ( '.' SmallWord )* ( '.' CapitalWord ) ;
    public final AntlrParser.uimaType_return uimaType() throws RecognitionException {
        AntlrParser.uimaType_return retval = new AntlrParser.uimaType_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token SmallWord155=null;
        Token char_literal156=null;
        Token SmallWord157=null;
        Token char_literal158=null;
        Token CapitalWord159=null;

        Object SmallWord155_tree=null;
        Object char_literal156_tree=null;
        Object SmallWord157_tree=null;
        Object char_literal158_tree=null;
        Object CapitalWord159_tree=null;

        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:216:9: ( SmallWord ( '.' SmallWord )* ( '.' CapitalWord ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:216:11: SmallWord ( '.' SmallWord )* ( '.' CapitalWord )
            {
            root_0 = (Object)adaptor.nil();

            SmallWord155=(Token)match(input,SmallWord,FOLLOW_SmallWord_in_uimaType1376); 
            SmallWord155_tree = (Object)adaptor.create(SmallWord155);
            adaptor.addChild(root_0, SmallWord155_tree);

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:216:21: ( '.' SmallWord )*
            loop44:
            do {
                int alt44=2;
                int LA44_0 = input.LA(1);

                if ( (LA44_0==76) ) {
                    int LA44_1 = input.LA(2);

                    if ( (LA44_1==SmallWord) ) {
                        alt44=1;
                    }


                }


                switch (alt44) {
            	case 1 :
            	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:216:22: '.' SmallWord
            	    {
            	    char_literal156=(Token)match(input,76,FOLLOW_76_in_uimaType1379); 
            	    char_literal156_tree = (Object)adaptor.create(char_literal156);
            	    adaptor.addChild(root_0, char_literal156_tree);

            	    SmallWord157=(Token)match(input,SmallWord,FOLLOW_SmallWord_in_uimaType1380); 
            	    SmallWord157_tree = (Object)adaptor.create(SmallWord157);
            	    adaptor.addChild(root_0, SmallWord157_tree);


            	    }
            	    break;

            	default :
            	    break loop44;
                }
            } while (true);

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:216:37: ( '.' CapitalWord )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:216:38: '.' CapitalWord
            {
            char_literal158=(Token)match(input,76,FOLLOW_76_in_uimaType1385); 
            char_literal158_tree = (Object)adaptor.create(char_literal158);
            adaptor.addChild(root_0, char_literal158_tree);

            CapitalWord159=(Token)match(input,CapitalWord,FOLLOW_CapitalWord_in_uimaType1386); 
            CapitalWord159_tree = (Object)adaptor.create(CapitalWord159);
            adaptor.addChild(root_0, CapitalWord159_tree);


            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "uimaType"

    public static class uimaFeat_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "uimaFeat"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:217:1: uimaFeat : SmallWord ( '[' Number ']' )? ;
    public final AntlrParser.uimaFeat_return uimaFeat() throws RecognitionException {
        AntlrParser.uimaFeat_return retval = new AntlrParser.uimaFeat_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token SmallWord160=null;
        Token char_literal161=null;
        Token Number162=null;
        Token char_literal163=null;

        Object SmallWord160_tree=null;
        Object char_literal161_tree=null;
        Object Number162_tree=null;
        Object char_literal163_tree=null;

        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:217:9: ( SmallWord ( '[' Number ']' )? )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:217:12: SmallWord ( '[' Number ']' )?
            {
            root_0 = (Object)adaptor.nil();

            SmallWord160=(Token)match(input,SmallWord,FOLLOW_SmallWord_in_uimaFeat1394); 
            SmallWord160_tree = (Object)adaptor.create(SmallWord160);
            adaptor.addChild(root_0, SmallWord160_tree);

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:217:22: ( '[' Number ']' )?
            int alt45=2;
            int LA45_0 = input.LA(1);

            if ( (LA45_0==83) ) {
                alt45=1;
            }
            switch (alt45) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:217:23: '[' Number ']'
                    {
                    char_literal161=(Token)match(input,83,FOLLOW_83_in_uimaFeat1397); 
                    char_literal161_tree = (Object)adaptor.create(char_literal161);
                    adaptor.addChild(root_0, char_literal161_tree);

                    Number162=(Token)match(input,Number,FOLLOW_Number_in_uimaFeat1398); 
                    Number162_tree = (Object)adaptor.create(Number162);
                    adaptor.addChild(root_0, Number162_tree);

                    char_literal163=(Token)match(input,84,FOLLOW_84_in_uimaFeat1400); 
                    char_literal163_tree = (Object)adaptor.create(char_literal163);
                    adaptor.addChild(root_0, char_literal163_tree);


                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "uimaFeat"

    public static class uimaTypePR_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "uimaTypePR"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:218:1: uimaTypePR : uimaType -> ^( UIMATYPE uimaType ) ;
    public final AntlrParser.uimaTypePR_return uimaTypePR() throws RecognitionException {
        AntlrParser.uimaTypePR_return retval = new AntlrParser.uimaTypePR_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AntlrParser.uimaType_return uimaType164 = null;


        RewriteRuleSubtreeStream stream_uimaType=new RewriteRuleSubtreeStream(adaptor,"rule uimaType");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:218:11: ( uimaType -> ^( UIMATYPE uimaType ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:218:13: uimaType
            {
            pushFollow(FOLLOW_uimaType_in_uimaTypePR1408);
            uimaType164=uimaType();

            state._fsp--;

            stream_uimaType.add(uimaType164.getTree());


            // AST REWRITE
            // elements: uimaType
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 218:22: -> ^( UIMATYPE uimaType )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:218:25: ^( UIMATYPE uimaType )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(UIMATYPE, "UIMATYPE"), root_1);

                adaptor.addChild(root_1, stream_uimaType.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "uimaTypePR"

    public static class uimaTypeAndFeats_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "uimaTypeAndFeats"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:219:1: uimaTypeAndFeats : '_' uimaType ( ':' feat+= uimaFeat ( '/' feat+= uimaFeat )* )? -> ^( UIMATYPEANDFEATS ^( UIMATYPE uimaType ) ( ^( UIMAFEAT ( $feat)+ ) )? ) ;
    public final AntlrParser.uimaTypeAndFeats_return uimaTypeAndFeats() throws RecognitionException {
        AntlrParser.uimaTypeAndFeats_return retval = new AntlrParser.uimaTypeAndFeats_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal165=null;
        Token char_literal167=null;
        Token char_literal168=null;
        List list_feat=null;
        AntlrParser.uimaType_return uimaType166 = null;

        RuleReturnScope feat = null;
        Object char_literal165_tree=null;
        Object char_literal167_tree=null;
        Object char_literal168_tree=null;
        RewriteRuleTokenStream stream_66=new RewriteRuleTokenStream(adaptor,"token 66");
        RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81");
        RewriteRuleTokenStream stream_85=new RewriteRuleTokenStream(adaptor,"token 85");
        RewriteRuleSubtreeStream stream_uimaFeat=new RewriteRuleSubtreeStream(adaptor,"rule uimaFeat");
        RewriteRuleSubtreeStream stream_uimaType=new RewriteRuleSubtreeStream(adaptor,"rule uimaType");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:219:17: ( '_' uimaType ( ':' feat+= uimaFeat ( '/' feat+= uimaFeat )* )? -> ^( UIMATYPEANDFEATS ^( UIMATYPE uimaType ) ( ^( UIMAFEAT ( $feat)+ ) )? ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:219:19: '_' uimaType ( ':' feat+= uimaFeat ( '/' feat+= uimaFeat )* )?
            {
            char_literal165=(Token)match(input,85,FOLLOW_85_in_uimaTypeAndFeats1422);  
            stream_85.add(char_literal165);

            pushFollow(FOLLOW_uimaType_in_uimaTypeAndFeats1423);
            uimaType166=uimaType();

            state._fsp--;

            stream_uimaType.add(uimaType166.getTree());
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:219:31: ( ':' feat+= uimaFeat ( '/' feat+= uimaFeat )* )?
            int alt47=2;
            int LA47_0 = input.LA(1);

            if ( (LA47_0==66) ) {
                alt47=1;
            }
            switch (alt47) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:219:32: ':' feat+= uimaFeat ( '/' feat+= uimaFeat )*
                    {
                    char_literal167=(Token)match(input,66,FOLLOW_66_in_uimaTypeAndFeats1426);  
                    stream_66.add(char_literal167);

                    pushFollow(FOLLOW_uimaFeat_in_uimaTypeAndFeats1430);
                    feat=uimaFeat();

                    state._fsp--;

                    stream_uimaFeat.add(feat.getTree());
                    if (list_feat==null) list_feat=new ArrayList();
                    list_feat.add(feat.getTree());

                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:219:51: ( '/' feat+= uimaFeat )*
                    loop46:
                    do {
                        int alt46=2;
                        int LA46_0 = input.LA(1);

                        if ( (LA46_0==81) ) {
                            alt46=1;
                        }


                        switch (alt46) {
                    	case 1 :
                    	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:219:52: '/' feat+= uimaFeat
                    	    {
                    	    char_literal168=(Token)match(input,81,FOLLOW_81_in_uimaTypeAndFeats1433);  
                    	    stream_81.add(char_literal168);

                    	    pushFollow(FOLLOW_uimaFeat_in_uimaTypeAndFeats1437);
                    	    feat=uimaFeat();

                    	    state._fsp--;

                    	    stream_uimaFeat.add(feat.getTree());
                    	    if (list_feat==null) list_feat=new ArrayList();
                    	    list_feat.add(feat.getTree());


                    	    }
                    	    break;

                    	default :
                    	    break loop46;
                        }
                    } while (true);


                    }
                    break;

            }



            // AST REWRITE
            // elements: uimaType, feat
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: feat
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
            RewriteRuleSubtreeStream stream_feat=new RewriteRuleSubtreeStream(adaptor,"token feat",list_feat);
            root_0 = (Object)adaptor.nil();
            // 220:3: -> ^( UIMATYPEANDFEATS ^( UIMATYPE uimaType ) ( ^( UIMAFEAT ( $feat)+ ) )? )
            {
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:220:6: ^( UIMATYPEANDFEATS ^( UIMATYPE uimaType ) ( ^( UIMAFEAT ( $feat)+ ) )? )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(UIMATYPEANDFEATS, "UIMATYPEANDFEATS"), root_1);

                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:220:25: ^( UIMATYPE uimaType )
                {
                Object root_2 = (Object)adaptor.nil();
                root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(UIMATYPE, "UIMATYPE"), root_2);

                adaptor.addChild(root_2, stream_uimaType.nextTree());

                adaptor.addChild(root_1, root_2);
                }
                // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:220:46: ( ^( UIMAFEAT ( $feat)+ ) )?
                if ( stream_feat.hasNext() ) {
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:220:46: ^( UIMAFEAT ( $feat)+ )
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(UIMAFEAT, "UIMAFEAT"), root_2);

                    if ( !(stream_feat.hasNext()) ) {
                        throw new RewriteEarlyExitException();
                    }
                    while ( stream_feat.hasNext() ) {
                        adaptor.addChild(root_2, stream_feat.nextTree());

                    }
                    stream_feat.reset();

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_feat.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "uimaTypeAndFeats"

    public static class ontClass_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "ontClass"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:221:1: ontClass : ( '<' namespace CapitalWord '>' -> namespace CapitalWord | prefix ':' CapitalWord );
    public final AntlrParser.ontClass_return ontClass() throws RecognitionException {
        AntlrParser.ontClass_return retval = new AntlrParser.ontClass_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal169=null;
        Token CapitalWord171=null;
        Token char_literal172=null;
        Token char_literal174=null;
        Token CapitalWord175=null;
        AntlrParser.namespace_return namespace170 = null;

        AntlrParser.prefix_return prefix173 = null;


        Object char_literal169_tree=null;
        Object CapitalWord171_tree=null;
        Object char_literal172_tree=null;
        Object char_literal174_tree=null;
        Object CapitalWord175_tree=null;
        RewriteRuleTokenStream stream_CapitalWord=new RewriteRuleTokenStream(adaptor,"token CapitalWord");
        RewriteRuleTokenStream stream_86=new RewriteRuleTokenStream(adaptor,"token 86");
        RewriteRuleTokenStream stream_87=new RewriteRuleTokenStream(adaptor,"token 87");
        RewriteRuleSubtreeStream stream_namespace=new RewriteRuleSubtreeStream(adaptor,"rule namespace");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:222:2: ( '<' namespace CapitalWord '>' -> namespace CapitalWord | prefix ':' CapitalWord )
            int alt48=2;
            int LA48_0 = input.LA(1);

            if ( (LA48_0==86) ) {
                alt48=1;
            }
            else if ( (LA48_0==SmallWord) ) {
                alt48=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 48, 0, input);

                throw nvae;
            }
            switch (alt48) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:222:5: '<' namespace CapitalWord '>'
                    {
                    char_literal169=(Token)match(input,86,FOLLOW_86_in_ontClass1475);  
                    stream_86.add(char_literal169);

                    pushFollow(FOLLOW_namespace_in_ontClass1477);
                    namespace170=namespace();

                    state._fsp--;

                    stream_namespace.add(namespace170.getTree());
                    CapitalWord171=(Token)match(input,CapitalWord,FOLLOW_CapitalWord_in_ontClass1479);  
                    stream_CapitalWord.add(CapitalWord171);

                    char_literal172=(Token)match(input,87,FOLLOW_87_in_ontClass1481);  
                    stream_87.add(char_literal172);



                    // AST REWRITE
                    // elements: CapitalWord, namespace
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 222:35: -> namespace CapitalWord
                    {
                        adaptor.addChild(root_0, stream_namespace.nextTree());
                        adaptor.addChild(root_0, stream_CapitalWord.nextNode());

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:223:5: prefix ':' CapitalWord
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_prefix_in_ontClass1493);
                    prefix173=prefix();

                    state._fsp--;

                    adaptor.addChild(root_0, prefix173.getTree());
                    char_literal174=(Token)match(input,66,FOLLOW_66_in_ontClass1495); 
                    char_literal174_tree = (Object)adaptor.create(char_literal174);
                    adaptor.addChild(root_0, char_literal174_tree);

                    CapitalWord175=(Token)match(input,CapitalWord,FOLLOW_CapitalWord_in_ontClass1497); 
                    CapitalWord175_tree = (Object)adaptor.create(CapitalWord175);
                    adaptor.addChild(root_0, CapitalWord175_tree);


                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "ontClass"

    public static class ontProperty_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "ontProperty"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:225:1: ontProperty : ( '<' namespace SmallWord '>' -> namespace SmallWord | prefix ':' SmallWord );
    public final AntlrParser.ontProperty_return ontProperty() throws RecognitionException {
        AntlrParser.ontProperty_return retval = new AntlrParser.ontProperty_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal176=null;
        Token SmallWord178=null;
        Token char_literal179=null;
        Token char_literal181=null;
        Token SmallWord182=null;
        AntlrParser.namespace_return namespace177 = null;

        AntlrParser.prefix_return prefix180 = null;


        Object char_literal176_tree=null;
        Object SmallWord178_tree=null;
        Object char_literal179_tree=null;
        Object char_literal181_tree=null;
        Object SmallWord182_tree=null;
        RewriteRuleTokenStream stream_SmallWord=new RewriteRuleTokenStream(adaptor,"token SmallWord");
        RewriteRuleTokenStream stream_86=new RewriteRuleTokenStream(adaptor,"token 86");
        RewriteRuleTokenStream stream_87=new RewriteRuleTokenStream(adaptor,"token 87");
        RewriteRuleSubtreeStream stream_namespace=new RewriteRuleSubtreeStream(adaptor,"rule namespace");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:226:2: ( '<' namespace SmallWord '>' -> namespace SmallWord | prefix ':' SmallWord )
            int alt49=2;
            int LA49_0 = input.LA(1);

            if ( (LA49_0==86) ) {
                alt49=1;
            }
            else if ( (LA49_0==SmallWord) ) {
                alt49=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 49, 0, input);

                throw nvae;
            }
            switch (alt49) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:226:5: '<' namespace SmallWord '>'
                    {
                    char_literal176=(Token)match(input,86,FOLLOW_86_in_ontProperty1508);  
                    stream_86.add(char_literal176);

                    pushFollow(FOLLOW_namespace_in_ontProperty1510);
                    namespace177=namespace();

                    state._fsp--;

                    stream_namespace.add(namespace177.getTree());
                    SmallWord178=(Token)match(input,SmallWord,FOLLOW_SmallWord_in_ontProperty1513);  
                    stream_SmallWord.add(SmallWord178);

                    char_literal179=(Token)match(input,87,FOLLOW_87_in_ontProperty1515);  
                    stream_87.add(char_literal179);



                    // AST REWRITE
                    // elements: namespace, SmallWord
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 226:34: -> namespace SmallWord
                    {
                        adaptor.addChild(root_0, stream_namespace.nextTree());
                        adaptor.addChild(root_0, stream_SmallWord.nextNode());

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:227:5: prefix ':' SmallWord
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_prefix_in_ontProperty1527);
                    prefix180=prefix();

                    state._fsp--;

                    adaptor.addChild(root_0, prefix180.getTree());
                    char_literal181=(Token)match(input,66,FOLLOW_66_in_ontProperty1529); 
                    char_literal181_tree = (Object)adaptor.create(char_literal181);
                    adaptor.addChild(root_0, char_literal181_tree);

                    SmallWord182=(Token)match(input,SmallWord,FOLLOW_SmallWord_in_ontProperty1531); 
                    SmallWord182_tree = (Object)adaptor.create(SmallWord182);
                    adaptor.addChild(root_0, SmallWord182_tree);


                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "ontProperty"

    public static class valueDatatype_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "valueDatatype"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:229:1: valueDatatype : ( Number -> ^( DATATYPEVALUE Number ) | '\\\"' ( word )+ '\\\"' -> ^( DATATYPEVALUE ( word )+ ) );
    public final AntlrParser.valueDatatype_return valueDatatype() throws RecognitionException {
        AntlrParser.valueDatatype_return retval = new AntlrParser.valueDatatype_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token Number183=null;
        Token char_literal184=null;
        Token char_literal186=null;
        AntlrParser.word_return word185 = null;


        Object Number183_tree=null;
        Object char_literal184_tree=null;
        Object char_literal186_tree=null;
        RewriteRuleTokenStream stream_Number=new RewriteRuleTokenStream(adaptor,"token Number");
        RewriteRuleTokenStream stream_88=new RewriteRuleTokenStream(adaptor,"token 88");
        RewriteRuleSubtreeStream stream_word=new RewriteRuleSubtreeStream(adaptor,"rule word");
        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:230:2: ( Number -> ^( DATATYPEVALUE Number ) | '\\\"' ( word )+ '\\\"' -> ^( DATATYPEVALUE ( word )+ ) )
            int alt51=2;
            int LA51_0 = input.LA(1);

            if ( (LA51_0==Number) ) {
                alt51=1;
            }
            else if ( (LA51_0==88) ) {
                alt51=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 51, 0, input);

                throw nvae;
            }
            switch (alt51) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:230:5: Number
                    {
                    Number183=(Token)match(input,Number,FOLLOW_Number_in_valueDatatype1542);  
                    stream_Number.add(Number183);



                    // AST REWRITE
                    // elements: Number
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 230:12: -> ^( DATATYPEVALUE Number )
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:230:15: ^( DATATYPEVALUE Number )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(DATATYPEVALUE, "DATATYPEVALUE"), root_1);

                        adaptor.addChild(root_1, stream_Number.nextNode());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:231:5: '\\\"' ( word )+ '\\\"'
                    {
                    char_literal184=(Token)match(input,88,FOLLOW_88_in_valueDatatype1556);  
                    stream_88.add(char_literal184);

                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:231:10: ( word )+
                    int cnt50=0;
                    loop50:
                    do {
                        int alt50=2;
                        int LA50_0 = input.LA(1);

                        if ( (LA50_0==Conf||(LA50_0>=SmallWord && LA50_0<=Number)) ) {
                            alt50=1;
                        }


                        switch (alt50) {
                    	case 1 :
                    	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:231:10: word
                    	    {
                    	    pushFollow(FOLLOW_word_in_valueDatatype1558);
                    	    word185=word();

                    	    state._fsp--;

                    	    stream_word.add(word185.getTree());

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt50 >= 1 ) break loop50;
                                EarlyExitException eee =
                                    new EarlyExitException(50, input);
                                throw eee;
                        }
                        cnt50++;
                    } while (true);

                    char_literal186=(Token)match(input,88,FOLLOW_88_in_valueDatatype1561);  
                    stream_88.add(char_literal186);



                    // AST REWRITE
                    // elements: word
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 231:21: -> ^( DATATYPEVALUE ( word )+ )
                    {
                        // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:231:24: ^( DATATYPEVALUE ( word )+ )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(DATATYPEVALUE, "DATATYPEVALUE"), root_1);

                        if ( !(stream_word.hasNext()) ) {
                            throw new RewriteEarlyExitException();
                        }
                        while ( stream_word.hasNext() ) {
                            adaptor.addChild(root_1, stream_word.nextTree());

                        }
                        stream_word.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "valueDatatype"

    public static class parameterName_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "parameterName"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:235:1: parameterName : SmallWord ;
    public final AntlrParser.parameterName_return parameterName() throws RecognitionException {
        AntlrParser.parameterName_return retval = new AntlrParser.parameterName_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token SmallWord187=null;

        Object SmallWord187_tree=null;

        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:235:14: ( SmallWord )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:235:16: SmallWord
            {
            root_0 = (Object)adaptor.nil();

            SmallWord187=(Token)match(input,SmallWord,FOLLOW_SmallWord_in_parameterName1580); 
            SmallWord187_tree = (Object)adaptor.create(SmallWord187);
            adaptor.addChild(root_0, SmallWord187_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "parameterName"

    public static class parameterValue_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "parameterValue"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:236:1: parameterValue : ( uimaType ( ':' uimaFeat )* | ontClass | ontProperty | word );
    public final AntlrParser.parameterValue_return parameterValue() throws RecognitionException {
        AntlrParser.parameterValue_return retval = new AntlrParser.parameterValue_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token char_literal189=null;
        AntlrParser.uimaType_return uimaType188 = null;

        AntlrParser.uimaFeat_return uimaFeat190 = null;

        AntlrParser.ontClass_return ontClass191 = null;

        AntlrParser.ontProperty_return ontProperty192 = null;

        AntlrParser.word_return word193 = null;


        Object char_literal189_tree=null;

        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:236:15: ( uimaType ( ':' uimaFeat )* | ontClass | ontProperty | word )
            int alt53=4;
            alt53 = dfa53.predict(input);
            switch (alt53) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:236:17: uimaType ( ':' uimaFeat )*
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_uimaType_in_parameterValue1586);
                    uimaType188=uimaType();

                    state._fsp--;

                    adaptor.addChild(root_0, uimaType188.getTree());
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:236:25: ( ':' uimaFeat )*
                    loop52:
                    do {
                        int alt52=2;
                        int LA52_0 = input.LA(1);

                        if ( (LA52_0==66) ) {
                            alt52=1;
                        }


                        switch (alt52) {
                    	case 1 :
                    	    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:236:26: ':' uimaFeat
                    	    {
                    	    char_literal189=(Token)match(input,66,FOLLOW_66_in_parameterValue1588); 
                    	    char_literal189_tree = (Object)adaptor.create(char_literal189);
                    	    adaptor.addChild(root_0, char_literal189_tree);

                    	    pushFollow(FOLLOW_uimaFeat_in_parameterValue1589);
                    	    uimaFeat190=uimaFeat();

                    	    state._fsp--;

                    	    adaptor.addChild(root_0, uimaFeat190.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop52;
                        }
                    } while (true);


                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:236:42: ontClass
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_ontClass_in_parameterValue1595);
                    ontClass191=ontClass();

                    state._fsp--;

                    adaptor.addChild(root_0, ontClass191.getTree());

                    }
                    break;
                case 3 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:236:53: ontProperty
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_ontProperty_in_parameterValue1599);
                    ontProperty192=ontProperty();

                    state._fsp--;

                    adaptor.addChild(root_0, ontProperty192.getTree());

                    }
                    break;
                case 4 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:236:67: word
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_word_in_parameterValue1603);
                    word193=word();

                    state._fsp--;

                    adaptor.addChild(root_0, word193.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "parameterValue"

    public static class word_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "word"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:238:1: word : ( SmallWord | CapitalWord | Number | numberWord | Conf );
    public final AntlrParser.word_return word() throws RecognitionException {
        AntlrParser.word_return retval = new AntlrParser.word_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token SmallWord194=null;
        Token CapitalWord195=null;
        Token Number196=null;
        Token Conf198=null;
        AntlrParser.numberWord_return numberWord197 = null;


        Object SmallWord194_tree=null;
        Object CapitalWord195_tree=null;
        Object Number196_tree=null;
        Object Conf198_tree=null;

        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:238:5: ( SmallWord | CapitalWord | Number | numberWord | Conf )
            int alt54=5;
            alt54 = dfa54.predict(input);
            switch (alt54) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:238:7: SmallWord
                    {
                    root_0 = (Object)adaptor.nil();

                    SmallWord194=(Token)match(input,SmallWord,FOLLOW_SmallWord_in_word1610); 
                    SmallWord194_tree = (Object)adaptor.create(SmallWord194);
                    adaptor.addChild(root_0, SmallWord194_tree);


                    }
                    break;
                case 2 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:238:19: CapitalWord
                    {
                    root_0 = (Object)adaptor.nil();

                    CapitalWord195=(Token)match(input,CapitalWord,FOLLOW_CapitalWord_in_word1614); 
                    CapitalWord195_tree = (Object)adaptor.create(CapitalWord195);
                    adaptor.addChild(root_0, CapitalWord195_tree);


                    }
                    break;
                case 3 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:238:33: Number
                    {
                    root_0 = (Object)adaptor.nil();

                    Number196=(Token)match(input,Number,FOLLOW_Number_in_word1618); 
                    Number196_tree = (Object)adaptor.create(Number196);
                    adaptor.addChild(root_0, Number196_tree);


                    }
                    break;
                case 4 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:238:42: numberWord
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_numberWord_in_word1622);
                    numberWord197=numberWord();

                    state._fsp--;

                    adaptor.addChild(root_0, numberWord197.getTree());

                    }
                    break;
                case 5 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:238:55: Conf
                    {
                    root_0 = (Object)adaptor.nil();

                    Conf198=(Token)match(input,Conf,FOLLOW_Conf_in_word1626); 
                    Conf198_tree = (Object)adaptor.create(Conf198);
                    adaptor.addChild(root_0, Conf198_tree);


                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "word"

    public static class numberWord_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "numberWord"
    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:240:1: numberWord : Number ( '_' | '-' )? ( CapitalWord | SmallWord ) ;
    public final AntlrParser.numberWord_return numberWord() throws RecognitionException {
        AntlrParser.numberWord_return retval = new AntlrParser.numberWord_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token Number199=null;
        Token set200=null;
        Token set201=null;

        Object Number199_tree=null;
        Object set200_tree=null;
        Object set201_tree=null;

        try {
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:240:11: ( Number ( '_' | '-' )? ( CapitalWord | SmallWord ) )
            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:240:13: Number ( '_' | '-' )? ( CapitalWord | SmallWord )
            {
            root_0 = (Object)adaptor.nil();

            Number199=(Token)match(input,Number,FOLLOW_Number_in_numberWord1633); 
            Number199_tree = (Object)adaptor.create(Number199);
            adaptor.addChild(root_0, Number199_tree);

            // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:240:20: ( '_' | '-' )?
            int alt55=2;
            int LA55_0 = input.LA(1);

            if ( (LA55_0==85||LA55_0==89) ) {
                alt55=1;
            }
            switch (alt55) {
                case 1 :
                    // E:\\java_workspace\\CODA_Parser_ANTLR\\src\\main\\java\\it\\uniroma2\\art\\coda\\projectionrule\\antlr\\Antlr.g:
                    {
                    set200=(Token)input.LT(1);
                    if ( input.LA(1)==85||input.LA(1)==89 ) {
                        input.consume();
                        adaptor.addChild(root_0, (Object)adaptor.create(set200));
                        state.errorRecovery=false;
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        throw mse;
                    }


                    }
                    break;

            }

            set201=(Token)input.LT(1);
            if ( (input.LA(1)>=SmallWord && input.LA(1)<=CapitalWord) ) {
                input.consume();
                adaptor.addChild(root_0, (Object)adaptor.create(set201));
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "numberWord"

    // Delegated rules


    protected DFA23 dfa23 = new DFA23(this);
    protected DFA26 dfa26 = new DFA26(this);
    protected DFA34 dfa34 = new DFA34(this);
    protected DFA36 dfa36 = new DFA36(this);
    protected DFA38 dfa38 = new DFA38(this);
    protected DFA53 dfa53 = new DFA53(this);
    protected DFA54 dfa54 = new DFA54(this);
    static final String DFA23_eotS =
        "\27\uffff";
    static final String DFA23_eofS =
        "\27\uffff";
    static final String DFA23_minS =
        "\1\6\2\110\1\27\1\110\2\20\1\106\1\27\1\110\2\uffff\1\6\1\17\2"+
        "\107\1\27\2\107\1\20\1\27\1\107\1\20";
    static final String DFA23_maxS =
        "\1\31\2\112\1\131\1\112\2\125\1\106\1\30\1\112\2\uffff\1\31\1\17"+
        "\2\107\1\131\2\107\1\125\1\30\1\107\1\125";
    static final String DFA23_acceptS =
        "\12\uffff\1\2\1\1\13\uffff";
    static final String DFA23_specialS =
        "\27\uffff}>";
    static final String[] DFA23_transitionS = {
            "\1\4\20\uffff\1\1\1\2\1\3",
            "\1\5\1\6\1\7",
            "\1\5\1\6\1\7",
            "\2\11\57\uffff\1\5\1\6\1\7\12\uffff\1\10\3\uffff\1\10",
            "\1\5\1\6\1\7",
            "\1\12\104\uffff\1\13",
            "\1\12\65\uffff\1\14\16\uffff\1\13",
            "\1\15",
            "\2\11",
            "\1\5\1\6\1\7",
            "",
            "",
            "\1\21\20\uffff\1\16\1\17\1\20",
            "\1\22",
            "\1\23",
            "\1\23",
            "\2\25\56\uffff\1\23\15\uffff\1\24\3\uffff\1\24",
            "\1\23",
            "\1\26",
            "\1\12\104\uffff\1\13",
            "\2\25",
            "\1\23",
            "\1\12\104\uffff\1\13"
    };

    static final short[] DFA23_eot = DFA.unpackEncodedString(DFA23_eotS);
    static final short[] DFA23_eof = DFA.unpackEncodedString(DFA23_eofS);
    static final char[] DFA23_min = DFA.unpackEncodedStringToUnsignedChars(DFA23_minS);
    static final char[] DFA23_max = DFA.unpackEncodedStringToUnsignedChars(DFA23_maxS);
    static final short[] DFA23_accept = DFA.unpackEncodedString(DFA23_acceptS);
    static final short[] DFA23_special = DFA.unpackEncodedString(DFA23_specialS);
    static final short[][] DFA23_transition;

    static {
        int numStates = DFA23_transitionS.length;
        DFA23_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA23_transition[i] = DFA.unpackEncodedString(DFA23_transitionS[i]);
        }
    }

    class DFA23 extends DFA {

        public DFA23(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 23;
            this.eot = DFA23_eot;
            this.eof = DFA23_eof;
            this.min = DFA23_min;
            this.max = DFA23_max;
            this.accept = DFA23_accept;
            this.special = DFA23_special;
            this.transition = DFA23_transition;
        }
        public String getDescription() {
            return "120:1: node : (idNode= word type= projType uimaTypeAndFeats -> ^( NODE ^( ID $idNode) ^( TYPE $type) uimaTypeAndFeats ) | idNode= word type= projType condIf -> ^( NODE ^( ID $idNode) ^( TYPE $type) condIf ) );";
        }
    }
    static final String DFA26_eotS =
        "\32\uffff";
    static final String DFA26_eofS =
        "\32\uffff";
    static final String DFA26_minS =
        "\1\27\1\uffff\1\116\1\102\1\120\1\27\1\6\2\uffff\2\114\1\27\1\114"+
        "\2\6\2\27\3\114\1\27\3\114\1\27\1\114";
    static final String DFA26_maxS =
        "\1\126\1\uffff\1\117\1\102\1\120\1\30\1\31\2\uffff\2\122\1\131"+
        "\1\122\2\31\2\30\1\122\2\127\1\131\3\122\1\30\1\122";
    static final String DFA26_acceptS =
        "\1\uffff\1\1\5\uffff\1\2\1\3\21\uffff";
    static final String DFA26_specialS =
        "\32\uffff}>";
    static final String[] DFA26_transitionS = {
            "\1\3\75\uffff\1\1\1\2",
            "",
            "\2\4",
            "\1\5",
            "\1\6",
            "\1\10\1\7",
            "\1\14\20\uffff\1\11\1\12\1\13",
            "",
            "",
            "\1\16\4\uffff\1\15\1\17",
            "\1\16\4\uffff\1\15\1\17",
            "\2\21\63\uffff\1\16\4\uffff\1\15\1\17\2\uffff\1\20\3\uffff"+
            "\1\20",
            "\1\16\4\uffff\1\15\1\17",
            "\1\25\20\uffff\1\22\1\23\1\24",
            "\1\25\20\uffff\1\26\1\27\1\24",
            "\1\10\1\7",
            "\2\21",
            "\1\16\4\uffff\1\15\1\17",
            "\1\16\4\uffff\1\15\1\17\4\uffff\1\10",
            "\1\16\4\uffff\1\15\1\17\4\uffff\1\7",
            "\2\31\63\uffff\1\16\4\uffff\1\15\1\17\2\uffff\1\30\3\uffff"+
            "\1\30",
            "\1\16\4\uffff\1\15\1\17",
            "\1\16\4\uffff\1\15\1\17",
            "\1\16\4\uffff\1\15\1\17",
            "\2\31",
            "\1\16\4\uffff\1\15\1\17"
    };

    static final short[] DFA26_eot = DFA.unpackEncodedString(DFA26_eotS);
    static final short[] DFA26_eof = DFA.unpackEncodedString(DFA26_eofS);
    static final char[] DFA26_min = DFA.unpackEncodedStringToUnsignedChars(DFA26_minS);
    static final char[] DFA26_max = DFA.unpackEncodedStringToUnsignedChars(DFA26_maxS);
    static final short[] DFA26_accept = DFA.unpackEncodedString(DFA26_acceptS);
    static final short[] DFA26_special = DFA.unpackEncodedString(DFA26_specialS);
    static final short[][] DFA26_transition;

    static {
        int numStates = DFA26_transitionS.length;
        DFA26_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA26_transition[i] = DFA.unpackEncodedString(DFA26_transitionS[i]);
        }
    }

    class DFA26 extends DFA {

        public DFA26(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 26;
            this.eot = DFA26_eot;
            this.eof = DFA26_eof;
            this.min = DFA26_min;
            this.max = DFA26_max;
            this.accept = DFA26_accept;
            this.special = DFA26_special;
            this.transition = DFA26_transition;
        }
        public String getDescription() {
            return "134:1: nodeIfElseValue : ( uimaTypeAndFeats -> uimaTypeAndFeats | ontClass -> ^( ONTORES ontClass ) | ontProperty -> ^( ONTORES ontProperty ) );";
        }
    }
    static final String DFA34_eotS =
        "\33\uffff";
    static final String DFA34_eofS =
        "\33\uffff";
    static final String DFA34_minS =
        "\1\27\1\uffff\1\116\1\102\1\uffff\1\120\1\27\1\6\2\uffff\2\114"+
        "\1\27\1\114\2\6\2\27\3\114\1\27\3\114\1\27\1\114";
    static final String DFA34_maxS =
        "\1\130\1\uffff\1\117\1\102\1\uffff\1\120\1\30\1\31\2\uffff\2\122"+
        "\1\131\1\122\2\31\2\30\1\122\2\127\1\131\3\122\1\30\1\122";
    static final String DFA34_acceptS =
        "\1\uffff\1\1\2\uffff\1\4\3\uffff\1\2\1\3\21\uffff";
    static final String DFA34_specialS =
        "\33\uffff}>";
    static final String[] DFA34_transitionS = {
            "\1\3\1\uffff\1\4\61\uffff\1\1\1\uffff\1\1\10\uffff\1\2\1\uffff"+
            "\1\4",
            "",
            "\2\5",
            "\1\6",
            "",
            "\1\7",
            "\1\11\1\10",
            "\1\15\20\uffff\1\12\1\13\1\14",
            "",
            "",
            "\1\17\4\uffff\1\16\1\20",
            "\1\17\4\uffff\1\16\1\20",
            "\2\22\63\uffff\1\17\4\uffff\1\16\1\20\2\uffff\1\21\3\uffff"+
            "\1\21",
            "\1\17\4\uffff\1\16\1\20",
            "\1\26\20\uffff\1\23\1\24\1\25",
            "\1\26\20\uffff\1\27\1\30\1\25",
            "\1\11\1\10",
            "\2\22",
            "\1\17\4\uffff\1\16\1\20",
            "\1\17\4\uffff\1\16\1\20\4\uffff\1\11",
            "\1\17\4\uffff\1\16\1\20\4\uffff\1\10",
            "\2\32\63\uffff\1\17\4\uffff\1\16\1\20\2\uffff\1\31\3\uffff"+
            "\1\31",
            "\1\17\4\uffff\1\16\1\20",
            "\1\17\4\uffff\1\16\1\20",
            "\1\17\4\uffff\1\16\1\20",
            "\2\32",
            "\1\17\4\uffff\1\16\1\20"
    };

    static final short[] DFA34_eot = DFA.unpackEncodedString(DFA34_eotS);
    static final short[] DFA34_eof = DFA.unpackEncodedString(DFA34_eofS);
    static final char[] DFA34_min = DFA.unpackEncodedStringToUnsignedChars(DFA34_minS);
    static final char[] DFA34_max = DFA.unpackEncodedStringToUnsignedChars(DFA34_maxS);
    static final short[] DFA34_accept = DFA.unpackEncodedString(DFA34_acceptS);
    static final short[] DFA34_special = DFA.unpackEncodedString(DFA34_specialS);
    static final short[][] DFA34_transition;

    static {
        int numStates = DFA34_transitionS.length;
        DFA34_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA34_transition[i] = DFA.unpackEncodedString(DFA34_transitionS[i]);
        }
    }

    class DFA34 extends DFA {

        public DFA34(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 34;
            this.eot = DFA34_eot;
            this.eof = DFA34_eof;
            this.min = DFA34_min;
            this.max = DFA34_max;
            this.accept = DFA34_accept;
            this.special = DFA34_special;
            this.transition = DFA34_transition;
        }
        public String getDescription() {
            return "175:1: tripleSubj : ( tripleElem | ontClass | ontProperty | valueDatatype );";
        }
    }
    static final String DFA36_eotS =
        "\33\uffff";
    static final String DFA36_eofS =
        "\33\uffff";
    static final String DFA36_minS =
        "\1\27\1\uffff\1\116\1\102\1\uffff\1\120\1\27\1\6\2\uffff\2\114"+
        "\1\27\1\114\2\6\2\27\3\114\1\27\3\114\1\27\1\114";
    static final String DFA36_maxS =
        "\1\130\1\uffff\1\117\1\102\1\uffff\1\120\1\30\1\31\2\uffff\2\122"+
        "\1\131\1\122\2\31\2\30\1\122\2\127\1\131\3\122\1\30\1\122";
    static final String DFA36_acceptS =
        "\1\uffff\1\1\2\uffff\1\4\3\uffff\1\2\1\3\21\uffff";
    static final String DFA36_specialS =
        "\33\uffff}>";
    static final String[] DFA36_transitionS = {
            "\1\3\1\uffff\1\4\61\uffff\1\1\1\uffff\1\1\10\uffff\1\2\1\uffff"+
            "\1\4",
            "",
            "\2\5",
            "\1\6",
            "",
            "\1\7",
            "\1\11\1\10",
            "\1\15\20\uffff\1\12\1\13\1\14",
            "",
            "",
            "\1\17\4\uffff\1\16\1\20",
            "\1\17\4\uffff\1\16\1\20",
            "\2\22\63\uffff\1\17\4\uffff\1\16\1\20\2\uffff\1\21\3\uffff"+
            "\1\21",
            "\1\17\4\uffff\1\16\1\20",
            "\1\26\20\uffff\1\24\1\23\1\25",
            "\1\26\20\uffff\1\27\1\30\1\25",
            "\1\11\1\10",
            "\2\22",
            "\1\17\4\uffff\1\16\1\20",
            "\1\17\4\uffff\1\16\1\20\4\uffff\1\10",
            "\1\17\4\uffff\1\16\1\20\4\uffff\1\11",
            "\2\32\63\uffff\1\17\4\uffff\1\16\1\20\2\uffff\1\31\3\uffff"+
            "\1\31",
            "\1\17\4\uffff\1\16\1\20",
            "\1\17\4\uffff\1\16\1\20",
            "\1\17\4\uffff\1\16\1\20",
            "\2\32",
            "\1\17\4\uffff\1\16\1\20"
    };

    static final short[] DFA36_eot = DFA.unpackEncodedString(DFA36_eotS);
    static final short[] DFA36_eof = DFA.unpackEncodedString(DFA36_eofS);
    static final char[] DFA36_min = DFA.unpackEncodedStringToUnsignedChars(DFA36_minS);
    static final char[] DFA36_max = DFA.unpackEncodedStringToUnsignedChars(DFA36_maxS);
    static final short[] DFA36_accept = DFA.unpackEncodedString(DFA36_acceptS);
    static final short[] DFA36_special = DFA.unpackEncodedString(DFA36_specialS);
    static final short[][] DFA36_transition;

    static {
        int numStates = DFA36_transitionS.length;
        DFA36_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA36_transition[i] = DFA.unpackEncodedString(DFA36_transitionS[i]);
        }
    }

    class DFA36 extends DFA {

        public DFA36(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 36;
            this.eot = DFA36_eot;
            this.eof = DFA36_eof;
            this.min = DFA36_min;
            this.max = DFA36_max;
            this.accept = DFA36_accept;
            this.special = DFA36_special;
            this.transition = DFA36_transition;
        }
        public String getDescription() {
            return "183:1: tripleObj : ( tripleElem | ontClass | ontProperty | valueDatatype );";
        }
    }
    static final String DFA38_eotS =
        "\16\uffff";
    static final String DFA38_eofS =
        "\16\uffff";
    static final String DFA38_minS =
        "\1\113\1\6\4\24\2\uffff\1\24\1\27\1\24\1\6\2\uffff";
    static final String DFA38_maxS =
        "\1\113\1\31\2\130\1\131\1\130\2\uffff\1\130\1\30\1\130\1\31\2\uffff";
    static final String DFA38_acceptS =
        "\6\uffff\1\1\1\2\4\uffff\2\1";
    static final String DFA38_specialS =
        "\16\uffff}>";
    static final String[] DFA38_transitionS = {
            "\1\1",
            "\1\5\20\uffff\1\2\1\3\1\4",
            "\1\6\2\uffff\1\6\1\uffff\1\6\50\uffff\1\7\1\uffff\1\6\6\uffff"+
            "\3\6\10\uffff\1\6\1\uffff\1\6",
            "\1\6\2\uffff\1\6\1\uffff\1\6\50\uffff\1\7\1\uffff\1\6\6\uffff"+
            "\3\6\10\uffff\1\6\1\uffff\1\6",
            "\1\6\2\uffff\1\10\1\12\1\6\50\uffff\1\7\1\uffff\1\6\6\uffff"+
            "\3\6\7\uffff\1\11\1\6\1\uffff\1\6\1\11",
            "\1\6\2\uffff\1\6\1\uffff\1\6\50\uffff\1\7\1\uffff\1\6\6\uffff"+
            "\3\6\10\uffff\1\6\1\uffff\1\6",
            "",
            "",
            "\1\6\2\uffff\1\6\1\uffff\1\6\50\uffff\1\13\1\uffff\1\6\6\uffff"+
            "\3\6\10\uffff\1\6\1\uffff\1\6",
            "\2\12",
            "\1\6\2\uffff\1\6\1\uffff\1\6\50\uffff\1\7\1\uffff\1\6\6\uffff"+
            "\3\6\10\uffff\1\6\1\uffff\1\6",
            "\1\7\20\uffff\1\15\1\14\1\7",
            "",
            ""
    };

    static final short[] DFA38_eot = DFA.unpackEncodedString(DFA38_eotS);
    static final short[] DFA38_eof = DFA.unpackEncodedString(DFA38_eofS);
    static final char[] DFA38_min = DFA.unpackEncodedStringToUnsignedChars(DFA38_minS);
    static final char[] DFA38_max = DFA.unpackEncodedStringToUnsignedChars(DFA38_maxS);
    static final short[] DFA38_accept = DFA.unpackEncodedString(DFA38_acceptS);
    static final short[] DFA38_special = DFA.unpackEncodedString(DFA38_specialS);
    static final short[][] DFA38_transition;

    static {
        int numStates = DFA38_transitionS.length;
        DFA38_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA38_transition[i] = DFA.unpackEncodedString(DFA38_transitionS[i]);
        }
    }

    class DFA38 extends DFA {

        public DFA38(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 38;
            this.eot = DFA38_eot;
            this.eof = DFA38_eof;
            this.min = DFA38_min;
            this.max = DFA38_max;
            this.accept = DFA38_accept;
            this.special = DFA38_special;
            this.transition = DFA38_transition;
        }
        public String getDescription() {
            return "191:1: refId : ( '$' word -> ^( PLACEHOLDER word ) | '$' idPR= word ':' nodeId= word -> ^( PLACEHOLDER $idPR $nodeId) );";
        }
    }
    static final String DFA53_eotS =
        "\33\uffff";
    static final String DFA53_eofS =
        "\33\uffff";
    static final String DFA53_minS =
        "\1\6\1\102\1\116\2\uffff\1\27\1\120\2\uffff\1\6\2\114\1\27\1\114"+
        "\2\6\2\27\3\114\1\27\3\114\1\27\1\114";
    static final String DFA53_maxS =
        "\1\126\1\114\1\117\2\uffff\1\30\1\120\2\uffff\1\31\2\122\1\131"+
        "\1\122\2\31\2\30\1\122\2\127\1\131\3\122\1\30\1\122";
    static final String DFA53_acceptS =
        "\3\uffff\1\4\1\1\2\uffff\1\2\1\3\22\uffff";
    static final String DFA53_specialS =
        "\33\uffff}>";
    static final String[] DFA53_transitionS = {
            "\1\3\20\uffff\1\1\2\3\74\uffff\1\2",
            "\1\5\1\uffff\2\3\6\uffff\1\4",
            "\2\6",
            "",
            "",
            "\1\10\1\7",
            "\1\11",
            "",
            "",
            "\1\15\20\uffff\1\12\1\13\1\14",
            "\1\17\4\uffff\1\16\1\20",
            "\1\17\4\uffff\1\16\1\20",
            "\2\22\63\uffff\1\17\4\uffff\1\16\1\20\2\uffff\1\21\3\uffff"+
            "\1\21",
            "\1\17\4\uffff\1\16\1\20",
            "\1\26\20\uffff\1\23\1\24\1\25",
            "\1\26\20\uffff\1\27\1\30\1\25",
            "\1\10\1\7",
            "\2\22",
            "\1\17\4\uffff\1\16\1\20",
            "\1\17\4\uffff\1\16\1\20\4\uffff\1\10",
            "\1\17\4\uffff\1\16\1\20\4\uffff\1\7",
            "\2\32\63\uffff\1\17\4\uffff\1\16\1\20\2\uffff\1\31\3\uffff"+
            "\1\31",
            "\1\17\4\uffff\1\16\1\20",
            "\1\17\4\uffff\1\16\1\20",
            "\1\17\4\uffff\1\16\1\20",
            "\2\32",
            "\1\17\4\uffff\1\16\1\20"
    };

    static final short[] DFA53_eot = DFA.unpackEncodedString(DFA53_eotS);
    static final short[] DFA53_eof = DFA.unpackEncodedString(DFA53_eofS);
    static final char[] DFA53_min = DFA.unpackEncodedStringToUnsignedChars(DFA53_minS);
    static final char[] DFA53_max = DFA.unpackEncodedStringToUnsignedChars(DFA53_maxS);
    static final short[] DFA53_accept = DFA.unpackEncodedString(DFA53_acceptS);
    static final short[] DFA53_special = DFA.unpackEncodedString(DFA53_specialS);
    static final short[][] DFA53_transition;

    static {
        int numStates = DFA53_transitionS.length;
        DFA53_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA53_transition[i] = DFA.unpackEncodedString(DFA53_transitionS[i]);
        }
    }

    class DFA53 extends DFA {

        public DFA53(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 53;
            this.eot = DFA53_eot;
            this.eof = DFA53_eof;
            this.min = DFA53_min;
            this.max = DFA53_max;
            this.accept = DFA53_accept;
            this.special = DFA53_special;
            this.transition = DFA53_transition;
        }
        public String getDescription() {
            return "236:1: parameterValue : ( uimaType ( ':' uimaFeat )* | ontClass | ontProperty | word );";
        }
    }
    static final String DFA54_eotS =
        "\17\uffff";
    static final String DFA54_eofS =
        "\17\uffff";
    static final String DFA54_minS =
        "\1\6\2\uffff\1\6\1\uffff\1\27\3\uffff\2\6\1\102\2\6\1\114";
    static final String DFA54_maxS =
        "\1\31\2\uffff\1\131\1\uffff\1\30\3\uffff\2\130\2\122\1\31\1\122";
    static final String DFA54_acceptS =
        "\1\uffff\1\1\1\2\1\uffff\1\5\1\uffff\1\3\1\4\1\3\6\uffff";
    static final String DFA54_specialS =
        "\17\uffff}>";
    static final String[] DFA54_transitionS = {
            "\1\4\20\uffff\1\1\1\2\1\3",
            "",
            "",
            "\3\6\10\uffff\1\6\2\uffff\1\10\2\uffff\1\6\2\10\50\uffff\1"+
            "\10\1\6\1\10\1\6\1\uffff\4\6\3\10\3\uffff\2\10\2\uffff\1\5\1"+
            "\10\1\uffff\1\10\1\7",
            "",
            "\1\11\1\7",
            "",
            "",
            "",
            "\3\7\10\uffff\1\7\2\uffff\1\7\2\uffff\3\7\50\uffff\4\7\1\uffff"+
            "\5\7\1\12\1\7\3\uffff\2\7\2\uffff\2\7\1\uffff\1\7",
            "\1\7\14\uffff\1\7\3\uffff\1\13\1\14\1\7\52\uffff\1\7\6\uffff"+
            "\1\7\1\uffff\1\7\10\uffff\1\7\1\uffff\1\7",
            "\1\7\11\uffff\1\15\4\uffff\2\7",
            "\1\10\20\uffff\3\10\50\uffff\1\10\1\uffff\1\10\7\uffff\1\7"+
            "\4\uffff\2\7",
            "\1\7\20\uffff\1\16\1\14\1\7",
            "\1\15\4\uffff\2\7"
    };

    static final short[] DFA54_eot = DFA.unpackEncodedString(DFA54_eotS);
    static final short[] DFA54_eof = DFA.unpackEncodedString(DFA54_eofS);
    static final char[] DFA54_min = DFA.unpackEncodedStringToUnsignedChars(DFA54_minS);
    static final char[] DFA54_max = DFA.unpackEncodedStringToUnsignedChars(DFA54_maxS);
    static final short[] DFA54_accept = DFA.unpackEncodedString(DFA54_acceptS);
    static final short[] DFA54_special = DFA.unpackEncodedString(DFA54_specialS);
    static final short[][] DFA54_transition;

    static {
        int numStates = DFA54_transitionS.length;
        DFA54_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA54_transition[i] = DFA.unpackEncodedString(DFA54_transitionS[i]);
        }
    }

    class DFA54 extends DFA {

        public DFA54(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 54;
            this.eot = DFA54_eot;
            this.eof = DFA54_eof;
            this.min = DFA54_min;
            this.max = DFA54_max;
            this.accept = DFA54_accept;
            this.special = DFA54_special;
            this.transition = DFA54_transition;
        }
        public String getDescription() {
            return "238:1: word : ( SmallWord | CapitalWord | Number | numberWord | Conf );";
        }
    }
 

    public static final BitSet FOLLOW_prefixRule_in_prRules72 = new BitSet(new long[]{0x0000000000800010L});
    public static final BitSet FOLLOW_prRule_in_prRules75 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_prefix_in_prefixRule112 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_prefixRule114 = new BitSet(new long[]{0x0000000000000000L,0x000000000000C000L});
    public static final BitSet FOLLOW_namespace_in_prefixRule117 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_65_in_prefixRule119 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RULE_in_prRule146 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_uimaTypePR_in_prRule148 = new BitSet(new long[]{0x00000000000001E0L,0x0000000000000008L});
    public static final BitSet FOLLOW_ID_in_prRule151 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_66_in_prRule153 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_prRule157 = new BitSet(new long[]{0x00000000000001C0L,0x0000000000000008L});
    public static final BitSet FOLLOW_Conf_in_prRule161 = new BitSet(new long[]{0x0000000000000180L,0x0000000000000008L});
    public static final BitSet FOLLOW_dependsOn_in_prRule164 = new BitSet(new long[]{0x0000000000000100L,0x0000000000000008L});
    public static final BitSet FOLLOW_imports_in_prRule167 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_67_in_prRule170 = new BitSet(new long[]{0x0000000000646000L,0x0000000000000012L});
    public static final BitSet FOLLOW_alias_in_prRule176 = new BitSet(new long[]{0x0000000000644000L,0x0000000000000012L});
    public static final BitSet FOLLOW_nodes_in_prRule179 = new BitSet(new long[]{0x0000000000640000L,0x0000000000000012L});
    public static final BitSet FOLLOW_graph_in_prRule182 = new BitSet(new long[]{0x0000000000600000L,0x0000000000000012L});
    public static final BitSet FOLLOW_where_in_prRule185 = new BitSet(new long[]{0x0000000000400000L,0x0000000000000012L});
    public static final BitSet FOLLOW_parameters_in_prRule188 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000012L});
    public static final BitSet FOLLOW_65_in_prRule191 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_68_in_prRule194 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DependsOn_in_dependsOn263 = new BitSet(new long[]{0x0000000000001E00L});
    public static final BitSet FOLLOW_dependency_in_dependsOn266 = new BitSet(new long[]{0x0000000000001E02L,0x0000000000000020L});
    public static final BitSet FOLLOW_69_in_dependsOn268 = new BitSet(new long[]{0x0000000000001E02L});
    public static final BitSet FOLLOW_Imports_in_imports294 = new BitSet(new long[]{0x0000000000001E00L});
    public static final BitSet FOLLOW_dependency_in_imports297 = new BitSet(new long[]{0x0000000000001E02L,0x0000000000000020L});
    public static final BitSet FOLLOW_69_in_imports299 = new BitSet(new long[]{0x0000000000001E02L});
    public static final BitSet FOLLOW_DependType1_in_dependency324 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_dependency326 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_dependency330 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_71_in_dependency332 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DependType2_in_dependency347 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_dependency349 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_dependency353 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
    public static final BitSet FOLLOW_69_in_dependency355 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_uimaTypePR_in_dependency357 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_71_in_dependency359 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DependType3_in_dependency376 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_dependency378 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_dependency382 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
    public static final BitSet FOLLOW_69_in_dependency384 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_dependency388 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
    public static final BitSet FOLLOW_69_in_dependency390 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_dependency395 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_71_in_dependency397 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DependTypeMult_in_dependency418 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_dependency420 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_dependency424 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
    public static final BitSet FOLLOW_69_in_dependency426 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_dependency431 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
    public static final BitSet FOLLOW_69_in_dependency433 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_dependency440 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_71_in_dependency442 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ALIAS_in_alias473 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_alias475 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_67_in_alias477 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_singleAlias_in_alias479 = new BitSet(new long[]{0x0000000003800040L,0x0000000000000010L});
    public static final BitSet FOLLOW_68_in_alias482 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ALIAS_in_alias497 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_alias499 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_67_in_alias501 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_68_in_alias503 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_word_in_singleAlias522 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
    public static final BitSet FOLLOW_uimaTypeAndFeats_in_singleAlias524 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NODES_in_nodes555 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_nodes557 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_67_in_nodes559 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_node_in_nodes561 = new BitSet(new long[]{0x0000000003800040L,0x0000000000000010L});
    public static final BitSet FOLLOW_68_in_nodes564 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NODES_in_nodes579 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_nodes581 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_67_in_nodes583 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_68_in_nodes585 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_word_in_node603 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000700L});
    public static final BitSet FOLLOW_projType_in_node607 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
    public static final BitSet FOLLOW_uimaTypeAndFeats_in_node609 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_word_in_node643 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000700L});
    public static final BitSet FOLLOW_projType_in_node647 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_condIf_in_node649 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_72_in_projType689 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_73_in_projType692 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000040L});
    public static final BitSet FOLLOW_lang_in_projType694 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_74_in_projType700 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_projType703 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_LITERALTYPE_in_projType705 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_71_in_projType707 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_70_in_lang720 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_lang722 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_71_in_lang724 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_uimaTypeAndFeats_in_nodeIfElseValue735 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ontClass_in_nodeIfElseValue744 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ontProperty_in_nodeIfElseValue757 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IF_in_condIf777 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_condValueAndUIMAType_in_condIf779 = new BitSet(new long[]{0x0000020000000002L});
    public static final BitSet FOLLOW_condElseIf_in_condIf781 = new BitSet(new long[]{0x0000020000000002L});
    public static final BitSet FOLLOW_condElse_in_condIf784 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_70_in_condValueAndUIMAType819 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_condBool_in_condValueAndUIMAType821 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_71_in_condValueAndUIMAType823 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_67_in_condValueAndUIMAType825 = new BitSet(new long[]{0x0000000000800010L,0x0000000000600000L});
    public static final BitSet FOLLOW_nodeIfElseValue_in_condValueAndUIMAType827 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_68_in_condValueAndUIMAType829 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_75_in_condBool851 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_condBool855 = new BitSet(new long[]{0x0000000000020000L});
    public static final BitSet FOLLOW_CONDOP_in_condBool857 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_condBool862 = new BitSet(new long[]{0x0000000003800042L});
    public static final BitSet FOLLOW_ELSE_in_condElseIf894 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_IF_in_condElseIf896 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_condValueAndUIMAType_in_condElseIf898 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ELSE_in_condElse918 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_67_in_condElse920 = new BitSet(new long[]{0x0000000000800010L,0x0000000000600000L});
    public static final BitSet FOLLOW_nodeIfElseValue_in_condElse922 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_68_in_condElse924 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GRAPH_in_graph945 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_graph947 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_67_in_graph949 = new BitSet(new long[]{0x0000000002880010L,0x0000000001602800L});
    public static final BitSet FOLLOW_singleTriple_in_graph951 = new BitSet(new long[]{0x0000000002880010L,0x0000000001602810L});
    public static final BitSet FOLLOW_68_in_graph954 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_tripleSubj_in_singleTriple975 = new BitSet(new long[]{0x0000000000900010L,0x0000000000602800L});
    public static final BitSet FOLLOW_triplePred_in_singleTriple978 = new BitSet(new long[]{0x0000000002800010L,0x0000000001602800L});
    public static final BitSet FOLLOW_tripleObj_in_singleTriple981 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_76_in_singleTriple983 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_OPTIONAL_in_singleTriple1017 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_67_in_singleTriple1019 = new BitSet(new long[]{0x0000000002800010L,0x0000000001602800L});
    public static final BitSet FOLLOW_tripleSubj_in_singleTriple1021 = new BitSet(new long[]{0x0000000000900010L,0x0000000000602800L});
    public static final BitSet FOLLOW_triplePred_in_singleTriple1024 = new BitSet(new long[]{0x0000000002800010L,0x0000000001602800L});
    public static final BitSet FOLLOW_tripleObj_in_singleTriple1027 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001010L});
    public static final BitSet FOLLOW_76_in_singleTriple1029 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_68_in_singleTriple1032 = new BitSet(new long[]{0x0000000000000002L,0x0000000000001000L});
    public static final BitSet FOLLOW_76_in_singleTriple1033 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_tripleElem_in_tripleSubj1074 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ontClass_in_tripleSubj1076 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ontProperty_in_tripleSubj1078 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_valueDatatype_in_tripleSubj1080 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_tripleElem_in_triplePred1093 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ontProperty_in_triplePred1095 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ABBR_in_triplePred1097 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_tripleElem_in_tripleObj1110 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ontClass_in_tripleObj1112 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ontProperty_in_tripleObj1114 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_valueDatatype_in_tripleObj1116 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_refId_in_tripleElem1132 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_var_in_tripleElem1134 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_75_in_refId1153 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_refId1155 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_75_in_refId1169 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_refId1173 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_66_in_refId1175 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_refId1179 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_77_in_var1204 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_var1206 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_WHERE_in_where1227 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_where1229 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_67_in_where1231 = new BitSet(new long[]{0x0000000002880010L,0x0000000001602800L});
    public static final BitSet FOLLOW_singleTriple_in_where1233 = new BitSet(new long[]{0x0000000002880010L,0x0000000001602810L});
    public static final BitSet FOLLOW_68_in_where1236 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PARAMETERS_in_parameters1258 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_parameters1260 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_67_in_parameters1262 = new BitSet(new long[]{0x0000000000800000L,0x0000000000000010L});
    public static final BitSet FOLLOW_parameterNameValue_in_parameters1265 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000030L});
    public static final BitSet FOLLOW_69_in_parameters1268 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_parameterNameValue_in_parameters1270 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000030L});
    public static final BitSet FOLLOW_68_in_parameters1278 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parameterName_in_parameterNameValue1302 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_parameterNameValue1305 = new BitSet(new long[]{0x0000000003800050L,0x0000000000600000L});
    public static final BitSet FOLLOW_parameterValue_in_parameterNameValue1309 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_namespace1341 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L});
    public static final BitSet FOLLOW_80_in_namespace1346 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_namespace1348 = new BitSet(new long[]{0x0000000000000000L,0x0000000000061000L});
    public static final BitSet FOLLOW_set_in_namespace1350 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_namespace1355 = new BitSet(new long[]{0x0000000000000000L,0x0000000000061000L});
    public static final BitSet FOLLOW_set_in_namespace1359 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SmallWord_in_prefix1370 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SmallWord_in_uimaType1376 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_76_in_uimaType1379 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_SmallWord_in_uimaType1380 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_76_in_uimaType1385 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_CapitalWord_in_uimaType1386 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SmallWord_in_uimaFeat1394 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080000L});
    public static final BitSet FOLLOW_83_in_uimaFeat1397 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_Number_in_uimaFeat1398 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
    public static final BitSet FOLLOW_84_in_uimaFeat1400 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_uimaType_in_uimaTypePR1408 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_85_in_uimaTypeAndFeats1422 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_uimaType_in_uimaTypeAndFeats1423 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_66_in_uimaTypeAndFeats1426 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_uimaFeat_in_uimaTypeAndFeats1430 = new BitSet(new long[]{0x0000000000000002L,0x0000000000020000L});
    public static final BitSet FOLLOW_81_in_uimaTypeAndFeats1433 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_uimaFeat_in_uimaTypeAndFeats1437 = new BitSet(new long[]{0x0000000000000002L,0x0000000000020000L});
    public static final BitSet FOLLOW_86_in_ontClass1475 = new BitSet(new long[]{0x0000000000000000L,0x000000000000C000L});
    public static final BitSet FOLLOW_namespace_in_ontClass1477 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_CapitalWord_in_ontClass1479 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});
    public static final BitSet FOLLOW_87_in_ontClass1481 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_prefix_in_ontClass1493 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_66_in_ontClass1495 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_CapitalWord_in_ontClass1497 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_86_in_ontProperty1508 = new BitSet(new long[]{0x0000000000000000L,0x000000000000C000L});
    public static final BitSet FOLLOW_namespace_in_ontProperty1510 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_SmallWord_in_ontProperty1513 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});
    public static final BitSet FOLLOW_87_in_ontProperty1515 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_prefix_in_ontProperty1527 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_66_in_ontProperty1529 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_SmallWord_in_ontProperty1531 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Number_in_valueDatatype1542 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_88_in_valueDatatype1556 = new BitSet(new long[]{0x0000000003800040L});
    public static final BitSet FOLLOW_word_in_valueDatatype1558 = new BitSet(new long[]{0x0000000003800040L,0x0000000001000000L});
    public static final BitSet FOLLOW_88_in_valueDatatype1561 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SmallWord_in_parameterName1580 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_uimaType_in_parameterValue1586 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_66_in_parameterValue1588 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_uimaFeat_in_parameterValue1589 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_ontClass_in_parameterValue1595 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ontProperty_in_parameterValue1599 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_word_in_parameterValue1603 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SmallWord_in_word1610 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CapitalWord_in_word1614 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Number_in_word1618 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_numberWord_in_word1622 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Conf_in_word1626 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Number_in_numberWord1633 = new BitSet(new long[]{0x0000000001800000L,0x0000000002200000L});
    public static final BitSet FOLLOW_set_in_numberWord1635 = new BitSet(new long[]{0x0000000001800000L});
    public static final BitSet FOLLOW_set_in_numberWord1642 = new BitSet(new long[]{0x0000000000000002L});

}